diff --git a/src/Makefile b/src/Makefile
index aa9bfa2..d42d9ed 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -2,7 +2,7 @@
 all: ikarus.fasl
 
 ikarus.fasl: 
-	echo '(load "compiler-6.2.ss")' | petite
+	echo '(load "compiler-6.9.ss")' | petite
 
 clean:
 	rm -f *.fasl
diff --git a/src/build-date.tmp b/src/build-date.tmp
index 597f7df..a33701c 100644
--- a/src/build-date.tmp
+++ b/src/build-date.tmp
@@ -1 +1 @@
-2006-08-02
+2006-08-22
diff --git a/src/chez-compat.ss b/src/chez-compat.ss
index 9de1539..9ef66bf 100644
--- a/src/chez-compat.ss
+++ b/src/chez-compat.ss
@@ -31,5 +31,27 @@
 
 (define char= char=?)
 
+(set! $base-rtd #%$base-rtd)
+(define-syntax |#primitive|
+  (syntax-rules ()
+    [(_ n prim) prim]
+    [(_ prim) prim]))
 
+(define (date-string)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
 
+(define ($record rtd . args)
+  (apply (record-constructor rtd) args))
+(define ($record/rtd? x rtd)
+  (and (record? x) (eq? (record-type-descriptor x) rtd)))
+(define ($record-ref x i)
+  ((record-field-accessor (record-type-descriptor x) i) x))
+(define ($record-set! x i v)
+  ((record-field-mutator (record-type-descriptor x) i) x v))
diff --git a/src/compiler-6.3.ss b/src/compiler-6.3.ss
new file mode 100644
index 0000000..88e1083
--- /dev/null
+++ b/src/compiler-6.3.ss
@@ -0,0 +1,3199 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1.ss")
+  (current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n"))
+
+(define primitive-set! set-top-level-value!)
+(load "record-case.ss")
+
+(load "libassembler-compat-6.0.ss") ; defines make-code etc.
+(load "libintelasm-6.0.ss") ; uses make-code, etc.
+(load "libfasl-6.0.ss") ; uses code? etc.
+
+
+
+(load "tests-driver.ss")
+(print-gensym #f)
+(gensym-prefix "L_")
+
+
+(define assembler-output (make-parameter #t))
+
+(load "set-operations.ss")
+;(load "tests-5.6-req.scm")
+;(load "tests-5.3-req.scm")
+;(load "tests-5.2-req.scm")
+;(load "tests-5.1-req.scm")
+;(load "tests-4.3-req.scm")
+;(load "tests-4.2-req.scm")
+
+;(load "tests-4.1-req.scm")
+;(load "tests-3.4-req.scm")
+
+;(load "tests-3.3-req.scm")
+;(load "tests-3.2-req.scm")
+;(load "tests-3.1-req.scm")
+;(load "tests-2.9-req.scm")
+;(load "tests-2.8-req.scm")
+;(load "tests-2.6-req.scm")
+;(load "tests-2.4-req.scm")
+;(load "tests-2.3-req.scm")
+;(load "tests-2.2-req.scm")
+;(load "tests-2.1-req.scm")
+;(load "tests-1.9-req.scm")
+;(load "tests-1.8-req.scm")
+;(load "tests-1.7-req.scm")
+;(load "tests-1.6-req.scm")
+;(load "tests-1.5-req.scm")
+;(load "tests-1.4-req.scm")
+;(load "tests-1.3-req.scm")
+;(load "tests-1.2-req.scm")
+;(load "tests-1.1-req.scm")
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.1.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ;["libexpand-6.2.ss"      "libexpand.fasl"]
+    ;["libcompile-6.4.ss"     "libcompile.fasl"]
+    ["psyntax-7.1.ss"        "psyntax.fasl"]
+    ["libinterpret-6.1.ss"   "libinterpret.fasl"]
+    ;["libintelasm-6.0.ss"    "libintelasm.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+(define primitive?
+  (lambda (x)
+    (or (assq x open-coded-primitives)
+        (memq x public-primitives))))
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    ;;;
+    ;;; asm
+    ;;;
+    ;[code?              1    pred]
+    ;[$code-instr-size   1    value]
+    ;[$code-reloc-size   1    value]
+    ;[$code-closure-size 1    value]
+    ;[$code->closure     1    value]
+    ;[$set-code-byte!    3    effect]
+    ;[$set-code-word!    3    effect]
+    ;[$set-code-object!  4    effect]
+    ;[$set-code-object+offset!  5    effect]
+    ;[$set-code-object+offset/rel!  5    effect]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+
+;;; primitives table section
+(define primitives-table
+ '(;;; system locations used by the C/Scheme interface
+   [$apply-nonprocedure-error-handler library]
+   [$incorrect-args-error-handler     library]
+   [$multiple-values-error            library]
+   [$intern                           library]
+   [do-overflow                       library]
+   [do-vararg-overflow                library]
+   [do-stack-overflow                 library]
+   ;;; type predicates
+   [fixnum?                 public]
+   [immediate?              public]
+   [boolean?                public]
+   [char?                   public]
+   [null?                   public]
+   [pair?                   public]
+   [symbol?                 public]
+   [vector?                 public]
+   [string?                 public]
+   [procedure?              public]
+   [eof-object?             public]
+   [not                     public]
+   [eq?                     public]
+   [equal?                  public]
+   ;;; fixnum primitives
+   [fxadd1                  public]
+   [fxsub1                  public]
+   [fx+                     public]
+   [fx-                     public]
+   [fx*                     public]
+   [fxsll                   public]
+   [fxsra                   public]
+   [fxlogor                 public]
+   [fxlogand                public]
+   [fxlogxor                public]
+   [fxlognot                public]
+   [fxquotient              public]
+   [fxremainder             public]
+   [fxmodulo                public]
+   ;;; fixnum predicates
+   [fxzero?                 public]
+   [fx=                     public]
+   [fx<                     public]
+   [fx<=                    public]
+   [fx>                     public]
+   [fx>=                    public]
+   ;;; characters
+   [char=?                  public]
+   [char<?                  public]
+   [char<=?                 public]
+   [char>?                  public]
+   [char>=?                 public]
+   [integer->char           public]
+   [char->integer           public]
+   ;;; lists
+   [cons                    public]
+   [car                     public]
+   [cdr                     public]
+   [caar                    public]
+   [cadr                    public]
+   [cdar                    public]
+   [cddr                    public]
+   [caaar                   public]
+   [caadr                   public]
+   [cadar                   public]
+   [caddr                   public]
+   [cdaar                   public]
+   [cdadr                   public]
+   [cddar                   public]
+   [cdddr                   public]
+   [caaaar                  public]
+   [caaadr                  public]
+   [caadar                  public]
+   [caaddr                  public]
+   [cadaar                  public]
+   [cadadr                  public]
+   [caddar                  public]
+   [cadddr                  public]
+   [cdaaar                  public]
+   [cdaadr                  public]
+   [cdadar                  public]
+   [cdaddr                  public]
+   [cddaar                  public]
+   [cddadr                  public]
+   [cdddar                  public]
+   [cddddr                  public]
+   [set-car!                public]
+   [set-cdr!                public]
+   [list                    public]
+   [list*                   ADDME]
+   [list?                   public]
+   [list-ref                public]
+   [length                  public]
+   [make-list               public]
+   [reverse                 public]
+   [append                  public]
+   [list-ref                public]
+   [memq                    public]
+   [memv                    public]
+   [assq                    public]
+   [map                     public]
+   [for-each                public]
+   [andmap                  public]
+   [ormap                   public]
+   ;;; vectors
+   [make-vector             public]
+   [vector                  public]
+   [vector-length           public]
+   [vector-ref              public]
+   [vector-set!             public]
+   [list->vector            public]
+   [vector->list            public]
+   ;;; strings
+   [make-string             public]
+   [string                  public]
+   [string-length           public]
+   [string-ref              public]
+   [string-set!             public]
+   [list->string            public]
+   [string->list            public]
+   [string-append           public]
+   [substring               public]
+   [string=?                public]
+   [fixnum->string          public]
+   ;;; symbols
+   [gensym                  public]
+   [gensym?                 public]
+   [symbol->string          public]
+   [gensym->unique-string   public]
+   [gensym-prefix           public]
+   [gensym-count            public]
+   [print-gensym            public]
+   [string->symbol          public]
+   [top-level-value         public]
+   [top-level-bound?        public]
+   [set-top-level-value!    public]
+   [primitive-set!          public]
+   [getprop                 public]
+   [putprop                 public]
+   [remprop                 public]
+   [property-list           public]
+   [oblist                  public]
+   [uuid                    public]
+   ;;; eof
+   [eof-object              public]
+   [void                    public]
+   ;;; control/debugging
+   [print-error             public]
+   [error                   public]
+   [current-error-handler   public]
+   [exit                    public]
+   [apply                   public]
+   [make-parameter          public]
+   ;;; output
+   [output-port?            public]
+   [console-output-port     public]
+   [current-output-port     public]
+   [standard-output-port    public]
+   [standard-error-port     public]
+   [open-output-file        public]
+   [open-output-string      public]
+   [with-output-to-file     public]
+   [call-with-output-file   public]
+   [with-input-from-file    public]
+   [call-with-input-file    public]
+   [get-output-string       public]
+   [close-output-port       public]
+   [flush-output-port       public]
+   [write-char              public]
+   [output-port-name        public]
+   [newline                 public]
+   ;;; input
+   [input-port?             public]
+   [standard-input-port     public]
+   [console-input-port      public]
+   [current-input-port      public]
+   [open-input-file         public]
+   [close-input-port        public]
+   [reset-input-port!       public]
+   [read-char               public]
+   [peek-char               public]
+   [unread-char             public]
+   [input-port-name         public]
+   ;;; writing/printing
+   [write                   public]
+   [display                 public]
+   [printf                  public]
+   [fprintf                 public]
+   [format                  public]
+   [read-token              public]
+   [read                    public]
+   ;;; evaluation
+   [primitive?              public]
+   [expand                  public]
+   [syntax-error            public]
+   [current-expand          public]
+   [expand-mode             public]
+   [compile-file            public]
+   [fasl-write              public]
+
+   [$sc-put-cte   public]
+   [sc-expand   public]
+   [$make-environment   public]
+   [environment?   public]
+   [interaction-environment   public]
+   [identifier?   public]
+   [syntax->list   public]
+   [syntax-object->datum   public]
+   [datum->syntax-object   public]
+   [generate-temporaries   public]
+   [free-identifier=?   public]
+   [bound-identifier=?   public]
+   [literal-identifier=?   public]
+   [syntax-error   public]
+   [$syntax-dispatch   public]
+
+
+
+   [interpret               public]
+   [eval                    public]
+   [current-eval            public]
+   [load                    public]
+   [new-cafe                public]
+   [collect                 public]
+   [call/cc                 public]
+   [call/cf                 library]
+   [dynamic-wind            public]
+   [values                  public]
+   [call-with-values        public]
+   [make-traced-procedure   library]
+   [trace-symbol!           library]
+   [untrace-symbol!         library]
+   ;;; record
+   [$base-rtd               library]
+   [record?                 public]
+   [record-rtd              public]
+   [record-name             public]
+   [record-printer          public]
+   [record-length           public]
+   [record-ref              public]
+   [record-set!             public]
+   ;;; record rtds
+   [make-record-type        public]
+   [record-constructor      public]
+   [record-predicate        public]
+   [record-field-accessor   public]
+   [record-field-mutator    public]
+   ;;; hash tables
+   [make-hash-table         public]
+   [hash-table?             public]
+   [get-hash-table          public]
+   [put-hash-table!         public]
+   ;;; asm
+   [make-code               public]
+   [code?                   public]
+   [make-code-executable!   public]
+   [code-instr-size         public]
+   [code-reloc-size         public]
+   [code-closure-size       public]
+   [set-code-byte!          public]
+   [set-code-word!          public]
+   [set-code-object!        public]
+   [set-code-foreign-object!        public]
+   [set-code-object+offset! public]
+   [set-code-object+offset/rel! public]
+   [set-code-object/reloc/relative!  public]
+   [code->closure           public]
+   [list*->code*            library]
+   ;;;
+   ;;; POSIX
+   ;;;
+   [fork                    public]
+   [posix-fork              public]
+   [system                  public]
+   [$debug                      public]
+   [$underflow-misaligned-error public]
+   ))
+
+(define (primitive? x)
+  (cond
+    [(assq x primitives-table) #t]
+    [(assq x open-coded-primitives) #t]
+    [else #f]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [(assq x primitives-table) #f]
+    [else (error 'open-codeable "invalid primitive ~s" x)]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record seq (e0 e1))
+(define-record function (arg* proper body))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define unique-var
+  (let ([counter 0])
+    (lambda (x)
+      (let ([g (gensym (format "~a:~a" x counter))])
+        (set! counter (fxadd1 counter))
+        (make-var g)))))
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (if (primitive? var)
+                (make-primref var)
+                (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (cond
+              [(primitive? var) (make-primref var)]
+              [else (error 'recordize "invalid top-level var ~s" var)]))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(function args proper body)
+       `(lambda ,(E-args proper args) ,(E body))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+;      [(function fml* proper body)
+;       (cond
+;         [proper 
+;          (if (fx= (length fml*) (length rand*))
+;              (make-bind fml* rand* body)
+;              (begin
+;                (warning 'compile "possible application error in ~s"
+;                         (unparse (make-funcall rator rand*)))
+;                (make-funcall rator rand*)))]
+;         [else
+;          (if (fx<= (length fml*) (length rand*))
+;              (make-bind fml* (properize fml* rand*) body)
+;              (begin
+;                (warning 'compile "possible application error in ~s"
+;                         (unparse (make-funcall rator rand*)))
+;                (make-funcall rator rand*)))])]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(function fml* proper body) 
+       (make-function fml* proper (Expr body))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) '()]
+      [else (union (Expr (car x*)) (Expr* (cdr x*)))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) '()]
+      [(var) '()]
+      [(primref) '()]
+      [(bind lhs* rhs* body)
+       (union (Expr body) (Expr* rhs*))]
+      [(conditional test conseq altern)
+       (union (Expr test) (union (Expr conseq) (Expr altern)))]
+      [(seq e0 e1) (union (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (Expr* (map clambda-case-body cls*))]
+      [(function fml* proper body) (Expr body)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (union (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (union (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (union (singleton lhs) (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+(define (rewrite-assignments assigned x)
+  (define who 'rewrite-assignments)
+  (define (fix lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix (cdr lhs*))])
+           (cond
+             [(memq x assigned) 
+              (let ([t (make-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(memq x assigned) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(function fml* proper body) 
+       (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)]) 
+         (make-function fml* proper 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (memq lhs assigned)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+  (let ([assigned (uncover-assigned x)])
+    (rewrite-assignments assigned x)))
+  
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(function fml* proper body) 
+       (let-values ([(body body-free) (Expr body)])
+         (let ([free (difference body-free fml*)])
+           (values (make-closure (make-code-rec fml* proper free body) free)
+                   free)))]
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? code? $forward-ptr? bwp-object?
+        pointer-value)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-instr-size $code-reloc-size $code-closure-size
+        $set-code-byte! $set-code-word! 
+        $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+        $make-record $record? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (simplify* arg* '() '()
+         (lambda (arg* lhs* rhs*)
+           (make-bind^ lhs* rhs* 
+             (make-primcall op arg*))))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list (make-constant n)))
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure code free*) 
+       (check-const (fx+ disp-closure-data (fx* (length free*) wordsize)) x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(vector)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp #t (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (case op
+;         [(values) (make-primcall op (simple* arg* r))]
+         [else (make-return (make-primcall op (simple* arg* r)))])]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'tail live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+         
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag bool-f)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-closuresize   12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+
+  (define record-ptag vector-tag)
+  (define record-pmask vector-mask)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define pagesize 4096)
+  (define dirty-word -1))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define (align n)
+    (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [(code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx< i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-instr-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag) 
+         (cons (sall (int fx-shift) eax) ac))]
+     [($code-reloc-size) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-closure-size) 
+       (indirect-ref arg* (fx- disp-code-closuresize vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $set-code-byte! $set-code-word!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? code? 
+       $record? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(apply) are-we-ever-here?
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   L_CALL
+                   (call (label SL_apply))
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else (error who "invalid convention ~s for call-cp" convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let ([Lf (unique-label)] [Ljoin (unique-label)])
+        (Pred test #f Lf
+          (Effect conseq
+            (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (NonTail val
+           (cons (movl eax (idx->frame-loc i)) ac))]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (NonTail body
+        (cond
+          [check
+           (list* 
+             (movl eax cpr) 
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac)]
+          [else
+           (list* 
+             (movl eax cpr) 
+             ac)]))]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(call-cp call-convention rp-convention idx argc mask)
+      (unless (eq? rp-convention 'tail)
+        (error who "nontail rp (~s) in tail context" rp-convention))
+      (let f ([i 0])
+        (cond
+          [(fx= i argc)
+           (case call-convention
+             [(normal) 
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (tail-indirect-cpr-call)
+                ac)]
+             [(apply)
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (jmp (label SL_apply)) 
+                ac)]
+             [else (error who "invalid conv ~s in tail call-cpr" convention)])]
+          [else
+            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+                                   (fx- 0 wordsize)) fpr)
+                         eax)
+                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (fx+ disp-closure-data (fx* wordsize (length free)))
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(list*->code*
+  (list
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list disp-closure-data
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list disp-closure-data
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list 
+          (fx+ disp-closure-data wordsize)
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    ))
+
+
+
+(define (compile-program original-program)
+  (let* (;;;
+         [p (sc-expand original-program)]
+         [p (recordize p)]
+         ;[f (pretty-print (unparse p))]
+         [p (optimize-direct-calls p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         ;[p (lift-complex-constants p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         ;[f (pretty-print (unparse p))]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         ;[f (pretty-print (unparse p))]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (fasl-write (car code*) (compile-port))))
+
+
+(define compile-expr
+  (lambda (expr output-file)
+    (let ([op (open-output-file output-file 'replace)])
+      (parameterize ([compile-port op])
+        (compile-program expr))
+      (close-output-port op))))
+
+(define compile-file
+  (lambda (input-file output-file)
+    (let ([ip (open-input-file input-file)]
+          [op (open-output-file output-file 'replace)])
+      (parameterize ([compile-port op]
+                     [expand-mode 'bootstrap])
+        (let f ()
+          (let ([x (read ip)])
+            (unless (eof-object? x)
+              (compile-program x)
+              (f)))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+
+(parameterize ([assembler-output #f])
+  (for-each 
+    (lambda (x)
+      (printf "compiling ~a ...\n" x)
+      (compile-file (car x) (cadr x)))
+    scheme-library-files))
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+
+(define replace-safe-prims-with-unsafe
+  (lambda (x)
+    (define prims
+      '([fx+ $fx+] [fx- $fx-] [fx* $fx*] [fxadd1 $fxadd1] [fxsub1 $fxsub1]
+        [fxlogand $fxlogand] [fxlogor $fxlogor] [fxlognot $fxlognot]
+        [fx= $fx=] [fx< $fx<] [fx<= $fx<=] [fx> $fx>] [fx>= $fx>=]
+        [fxzero? $fxzero?]
+        [fixnum->char $fixnum->char] [char->fixnum $char->fixnum]
+        [char= $char=] 
+        [char< $char<] [char> $char>] [char<= $char<=] [char>= $char>=]
+        [car $car] [cdr $cdr] [set-car! $set-car!] [set-cdr! $set-cdr!]
+        [vector-length $vector-length] [vector-ref $vector-ref] 
+        [vector-set! $vector-set!] [make-vector $make-vector]
+        [string-length $string-length] [string-ref $string-ref] 
+        [string-set! $string-set!] [make-string $make-string]
+        ))
+    (define (E x)
+      (cond
+        [(pair? x) (cons (E (car x)) (E (cdr x)))]
+        [(symbol? x)
+         (cond
+           [(assq x prims) => cadr]
+           [else x])]
+        [else x]))
+    (E x)))
+
+(parameterize ([input-filter 
+                (lambda (x)
+                  `(begin (write (eval ',x)) (newline) (exit 0)))])
+  (test-all))
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(compile-expr
+  `(begin
+     (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+     (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+     (new-cafe))
+  "petite-ikarus.fasl")
diff --git a/src/compiler-6.4.ss b/src/compiler-6.4.ss
new file mode 100644
index 0000000..da0089c
--- /dev/null
+++ b/src/compiler-6.4.ss
@@ -0,0 +1,98 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (set! $base-rtd (eval '#%$base-rtd))
+;  (set! $base-rtd #%$base-rtd)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n")
+  (load "libassembler-compat-6.0.ss") ; defines make-code etc.
+  (load "libintelasm-6.0.ss") ; uses make-code, etc.
+  (load "libfasl-6.0.ss") ; uses code? etc.
+  (load "libcompile-6.4.ss") ; uses fasl-write
+)
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-compat-6.0.ss" "libassembler-compat.ss"]
+    ["libintelasm-6.4.ss"    "libintelasm.fasl"]
+    ["libfasl-6.0.ss"        "libfasl.fasl"]
+    ["libcompile-6.4.ss"     "libcompile.fasl"]
+    ["psyntax-7.1.ss"        "psyntax.fasl"]
+    ["libinterpret-6.1.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] [expand-mode 'bootstrap])
+      (printf "compiling ~a ...\n" ifile)
+      (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(with-output-to-file "petite-ikarus.ss"
+  (lambda ()
+    (write 
+      `(begin
+         (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+         (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+         (new-cafe))))
+  'replace)
+
+(compile-library "petite-ikarus.ss" "petite-ikarus.fasl")
diff --git a/src/compiler-6.5.ss b/src/compiler-6.5.ss
new file mode 100644
index 0000000..f4dc5e2
--- /dev/null
+++ b/src/compiler-6.5.ss
@@ -0,0 +1,96 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.5.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n")
+  (load "libassembler-compat-6.0.ss") ; defines make-code etc.
+  (load "libintelasm-6.0.ss") ; uses make-code, etc.
+  (load "libfasl-6.0.ss") ; uses code? etc.
+  (load "libcompile-6.5.ss") ; uses fasl-write
+)
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-compat-6.0.ss" "libassembler-compat.ss"]
+    ["libintelasm-6.4.ss"    "libintelasm.fasl"]
+    ["libfasl-6.0.ss"        "libfasl.fasl"]
+    ["libcompile-6.5.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.5.ss"        "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] [expand-mode 'bootstrap])
+      (printf "compiling ~a ...\n" ifile)
+      (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(with-output-to-file "petite-ikarus.ss"
+  (lambda ()
+    (write 
+      `(begin
+         (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+         (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+         (new-cafe))))
+  'replace)
+
+(compile-library "petite-ikarus.ss" "petite-ikarus.fasl")
diff --git a/src/compiler-6.6.ss b/src/compiler-6.6.ss
new file mode 100644
index 0000000..b83900e
--- /dev/null
+++ b/src/compiler-6.6.ss
@@ -0,0 +1,97 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.5.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n")
+  (load "libassembler-compat-6.6.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.6.ss") ; uses code? etc.
+  (load "libcompile-6.6.ss") ; uses fasl-write
+)
+
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-compat-6.6.ss" "libassembler-compat.ss"]
+    ["libintelasm-6.6.ss"    "libintelasm.fasl"]
+    ["libfasl-6.6.ss"        "libfasl.fasl"]
+    ["libcompile-6.6.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.5.ss"        "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] [expand-mode 'bootstrap])
+      (printf "compiling ~a ...\n" ifile)
+      (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(with-output-to-file "petite-ikarus.ss"
+  (lambda ()
+    (write 
+      `(begin
+         (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+         (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+         (new-cafe))))
+  'replace)
+
+(compile-library "petite-ikarus.ss" "petite-ikarus.fasl")
diff --git a/src/compiler-6.7.ss b/src/compiler-6.7.ss
new file mode 100644
index 0000000..b19d43f
--- /dev/null
+++ b/src/compiler-6.7.ss
@@ -0,0 +1,98 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.5.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n")
+  (load "libassembler-compat-6.7.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.7.ss") ; uses code? etc.
+  (load "libcompile-6.7.ss") ; uses fasl-write
+)
+
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"   "libassembler.ss"]
+    ["libintelasm-6.6.ss"    "libintelasm.fasl"]
+    ["libfasl-6.7.ss"        "libfasl.fasl"]
+    ["libcompile-6.7.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.5.ss"    "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] 
+                 [expand-mode 'bootstrap])
+      (printf "compiling ~a ...\n" ifile)
+      (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(with-output-to-file "petite-ikarus.ss"
+  (lambda ()
+    (write 
+      `(begin
+         (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+         (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+         (new-cafe))))
+  'replace)
+
+(compile-library "petite-ikarus.ss" "petite-ikarus.fasl")
diff --git a/src/compiler-6.8.ss b/src/compiler-6.8.ss
new file mode 100644
index 0000000..e12cfaa
--- /dev/null
+++ b/src/compiler-6.8.ss
@@ -0,0 +1,98 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.5.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (printf "ok\n")
+  (load "libassembler-compat-6.7.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.7.ss") ; uses code? etc.
+  (load "libcompile-6.7.ss") ; uses fasl-write
+)
+
+
+
+(define scheme-library-files
+  '(["libhandlers-6.0.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.2.ss"        "libcore.fasl"]
+    ["libio-6.1.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"   "libassembler.ss"]
+    ["libintelasm-6.6.ss"    "libintelasm.fasl"]
+    ["libfasl-6.7.ss"        "libfasl.fasl"]
+    ["libcompile-6.7.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.8.ss"    "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+;    ["libtrace-5.3.ss"       "libtrace-5.3.s"       "libtrace"      ]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.0.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] 
+                 [expand-mode 'bootstrap])
+      (printf "compiling ~a ...\n" ifile)
+      (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+(system "rm -f ikarus.fasl")
+
+(for-each
+  (lambda (x)
+    (system (format "cat ~a >> ikarus.fasl" (cadr x))))
+  scheme-library-files)
+
+
+(define (get-date)
+  (system "date +\"%F\" > build-date.tmp")
+  (let ([ip (open-input-file "build-date.tmp")])
+    (list->string
+      (let f ()
+        (let ([x (read-char ip)])
+          (if (char=? x #\newline)
+              '()
+              (cons x (f))))))))
+  
+(with-output-to-file "petite-ikarus.ss"
+  (lambda ()
+    (write 
+      `(begin
+         (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date)))
+         (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+         (new-cafe))))
+  'replace)
+
+(compile-library "petite-ikarus.ss" "petite-ikarus.fasl")
diff --git a/src/compiler-6.9.ss b/src/compiler-6.9.ss
new file mode 100644
index 0000000..2a10256
--- /dev/null
+++ b/src/compiler-6.9.ss
@@ -0,0 +1,256 @@
+
+
+;;; 
+;;; 6.9: * creating a *system* environment
+;;; 6.8: * creating a core-primitive form in the expander
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+
+
+
+(define macros
+  '(|#primitive| lambda case-lambda set! quote begin define if letrec
+    foreign-call $apply
+    quasiquote unquote unquote-splicing
+    define-syntax identifier-syntax let-syntax letrec-syntax
+    fluid-let-syntax alias meta eval-when with-implicit with-syntax
+    type-descriptor
+    syntax-case syntax-rules module $module import $import import-only
+    syntax quasisyntax unsyntax unsyntax-splicing datum
+    let let* let-values cond case define-record or and when unless do
+    include parameterize trace untrace trace-lambda))
+
+
+
+(define public-primitives
+  '(null? pair? char? fixnum? symbol? gensym? string? vector? list?
+    boolean? procedure? 
+    not
+    eof-object eof-object? bwp-object?
+    void
+    fx= fx< fx<= fx> fx>= fxzero?
+    fx+ fx- fx* fxadd1 fxsub1 fxquotient fxremainder fxmodulo 
+    fxsll fxsra fxlognot fxlogor fxlogand fxlogxor
+    integer->char char->integer
+    char=? char<? char<=? char>? char>=?
+    cons car cdr set-car! set-cdr!
+    caar cadr cdar cddr 
+    caaar caadr cadar caddr cdaar cdadr cddar cdddr 
+    caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr 
+    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr 
+    list list* make-list length list-ref
+    append
+    make-vector vector-ref vector-set! vector-length vector
+    vector->list list->vector
+    make-string string-ref string-set! string-length string list->string
+    uuid
+    string-append substring 
+    string=? string<? string<=? string>? string>=?
+    remprop putprop getprop property-list
+    apply
+    map for-each andmap ormap
+    memq memv assq 
+    eq? equal?
+    reverse
+    string->symbol symbol->string oblist 
+    top-level-value set-top-level-value! top-level-bound?
+    gensym gensym-count gensym-prefix print-gensym
+    gensym->unique-string
+    call-with-values values
+    make-parameter dynamic-wind
+    output-port? current-output-port standard-output-port console-output-port
+    open-output-file close-output-port flush-output-port output-port-name
+    with-output-to-file with-input-from-file
+    input-port? current-input-port standard-input-port console-input-port
+    reset-input-port!
+    open-input-file close-input-port input-port-name
+    standard-error-port
+    open-output-string get-output-string 
+    newline write-char peek-char read-char unread-char
+    display write fasl-write printf format print-error
+    read-token read
+    error exit call/cc
+    current-error-handler
+    eval current-eval interpret compile compile-file new-cafe load
+    system
+    expand sc-expand current-expand expand-mode 
+    environment? interaction-environment
+    identifier? free-identifier=? bound-identifier=? literal-identifier=?
+    datum->syntax-object syntax-object->datum syntax-error
+    syntax->list
+    generate-temporaries
+    record? record-set! record-ref record-length
+    record-type-descriptor make-record-type
+    record-printer record-name record-field-accessor
+    record-field-mutator record-predicate record-constructor
+    record-type-name record-type-symbol record-type-field-names 
+    hash-table? make-hash-table get-hash-table put-hash-table!
+    assembler-output
+    $make-environment
+    features
+    ))
+
+(define system-primitives
+  '(immediate? $unbound-object? $forward-ptr?
+    pointer-value 
+    primitive-ref primitive-set!
+    $fx= $fx< $fx<= $fx> $fx>= $fxzero?
+    $fx+ $fx- $fx* $fxadd1 $fxsub1 $fxquotient $fxremainder $fxmodulo 
+    $fxsll $fxsra $fxlognot $fxlogor $fxlogand $fxlogxor
+    $fixnum->char $char->fixnum
+    $char= $char< $char<= $char> $char>=
+    $car $cdr $set-car! $set-cdr!
+    $make-vector $vector-ref $vector-set! $vector-length
+    $make-string $string-ref $string-set! $string-length $string
+    $symbol-string $symbol-unique-string $symbol-value
+    $set-symbol-string! $set-symbol-unique-string! $set-symbol-value!
+    $make-symbol $set-symbol-plist!  $symbol-plist
+    $sc-put-cte 
+    $record? $record/rtd? $record-set! $record-ref $record-rtd
+    $make-record $record
+    $base-rtd
+    $code? $code-reloc-vector $code-freevars $code-size $code-ref $code-set!
+    $code->closure list*->code* 
+    make-code code? set-code-reloc-vector! code-reloc-vector code-freevars
+    code-size code-ref code-set!
+    $frame->continuation $fp-at-base $current-frame $seal-frame-and-call
+    $make-call-with-values-procedure $make-values-procedure
+    do-overflow collect
+    $make-tcbucket $tcbucket-next $tcbucket-key $tcbucket-val
+    $set-tcbucket-next! $set-tcbucket-val! $set-tcbucket-tconc!
+    call/cf trace-symbol! untrace-symbol! make-traced-procedure
+    fixnum->string date-string
+    vector-memq vector-memv
+    ))
+ 
+
+
+(define (whack-system-env setenv?)
+  (define add-prim
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))])
+        (putprop x '|#system| g)
+        (putprop g '*sc-expander* (cons 'core-primitive x)))))
+  (define add-macro
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))]
+            [e (getprop x '*sc-expander*)])
+        (when e 
+          (putprop x '|#system| g)
+          (putprop g '*sc-expander* e)))))
+  (define (foo)
+    (eval 
+      `(begin
+         (define-syntax compile-time-date-string
+           (lambda (x)
+             #'(quote ,(#%date-string))))
+         (define-syntax public-primitives
+           (lambda (x)
+             #'(quote ,public-primitives)))
+         (define-syntax system-primitives
+           (lambda (x)
+             #'(quote ,system-primitives))) 
+         (define-syntax macros
+           (lambda (x)
+             #'(quote ,macros))))))
+  (set! system-env ($make-environment '|#system| #t))
+  (for-each add-macro macros)
+  (for-each add-prim public-primitives)
+  (for-each add-prim system-primitives)
+  (if setenv?
+      (parameterize ([interaction-environment system-env])
+        (foo))
+      (foo)))
+
+
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #f)
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.9.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #t)
+  (printf "ok\n")
+  (load "libassembler-compat-6.7.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.7.ss") ; uses code? etc.
+  (load "libcompile-6.7.ss") ; uses fasl-write
+)
+
+
+(whack-system-env #t)
+
+(define scheme-library-files
+  '(["libhandlers-6.9.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.9.ss"        "libcore.fasl"]
+    ["libio-6.9.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"   "libassembler.ss"]
+    ["libintelasm-6.9.ss"    "libintelasm.fasl"]
+    ["libfasl-6.7.ss"        "libfasl.fasl"]
+    ["libcompile-6.7.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.9.ss"    "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+    ["libtrace-6.9.ss"       "libtrace.fasl"]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.9.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] 
+                 [expand-mode 'bootstrap]
+                 [interaction-environment system-env])
+     (printf "compiling ~a ...\n" ifile)
+     (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+
+(define (join s ls)
+  (cond
+    [(null? ls) ""]
+    [else
+     (let ([str (open-output-string)])
+       (let f ([a (car ls)] [d (cdr ls)])
+         (cond
+           [(null? d)
+            (display a str)
+            (get-output-string str)]
+           [else
+            (display a str)
+            (display s str)
+            (f (car d) (cdr d))])))]))
+   
+
+(system
+  (format "cat ~a > ikarus.fasl"
+          (join " " (map cadr scheme-library-files))))
diff --git a/src/compiler-8.0.ss b/src/compiler-8.0.ss
new file mode 100644
index 0000000..bb1a651
--- /dev/null
+++ b/src/compiler-8.0.ss
@@ -0,0 +1,261 @@
+
+
+;;; 
+;;; 6.9: * creating a *system* environment
+;;; 6.8: * creating a core-primitive form in the expander
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+
+
+
+(define macros
+  '(|#primitive| lambda case-lambda set! quote begin define if letrec
+    foreign-call $apply
+    quasiquote unquote unquote-splicing
+    define-syntax identifier-syntax let-syntax letrec-syntax
+    fluid-let-syntax alias meta eval-when with-implicit with-syntax
+    type-descriptor
+    syntax-case syntax-rules module $module import $import import-only
+    syntax quasisyntax unsyntax unsyntax-splicing datum
+    let let* let-values cond case define-record or and when unless do
+    include parameterize trace untrace trace-lambda))
+
+
+
+(define public-primitives
+  '(null? pair? char? fixnum? symbol? gensym? string? vector? list?
+    boolean? procedure? 
+    not
+    eof-object eof-object? bwp-object?
+    void
+    fx= fx< fx<= fx> fx>= fxzero?
+    fx+ fx- fx* fxadd1 fxsub1 fxquotient fxremainder fxmodulo 
+    fxsll fxsra fxlognot fxlogor fxlogand fxlogxor
+    integer->char char->integer
+    char=? char<? char<=? char>? char>=?
+    cons car cdr set-car! set-cdr!
+    caar cadr cdar cddr 
+    caaar caadr cadar caddr cdaar cdadr cddar cdddr 
+    caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr 
+    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr 
+    list list* make-list length list-ref
+    append
+    make-vector vector-ref vector-set! vector-length vector
+    vector->list list->vector
+    make-string string-ref string-set! string-length string list->string
+    uuid
+    string-append substring 
+    string=? string<? string<=? string>? string>=?
+    remprop putprop getprop property-list
+    apply
+    map for-each andmap ormap
+    memq memv assq 
+    eq? equal?
+    reverse
+    string->symbol symbol->string oblist 
+    top-level-value set-top-level-value! top-level-bound?
+    gensym gensym-count gensym-prefix print-gensym
+    gensym->unique-string
+    call-with-values values
+    make-parameter dynamic-wind
+    output-port? current-output-port standard-output-port console-output-port
+    open-output-file close-output-port flush-output-port output-port-name
+    with-output-to-file with-input-from-file
+    input-port? current-input-port standard-input-port console-input-port
+    reset-input-port!
+    open-input-file close-input-port input-port-name
+    standard-error-port
+    open-output-string get-output-string 
+    newline write-char peek-char read-char unread-char
+    display write fasl-write printf format print-error
+    read-token read
+    error exit call/cc
+    current-error-handler
+    eval current-eval interpret compile compile-file new-cafe load
+    system
+    expand sc-expand current-expand expand-mode 
+    environment? interaction-environment
+    identifier? free-identifier=? bound-identifier=? literal-identifier=?
+    datum->syntax-object syntax-object->datum syntax-error
+    syntax->list
+    generate-temporaries
+    record? record-set! record-ref record-length
+    record-type-descriptor make-record-type
+    record-printer record-name record-field-accessor
+    record-field-mutator record-predicate record-constructor
+    record-type-name record-type-symbol record-type-field-names 
+    hash-table? make-hash-table get-hash-table put-hash-table!
+    assembler-output
+    $make-environment
+    features
+    ))
+
+(define system-primitives
+  '(immediate? $unbound-object? $forward-ptr?
+    pointer-value 
+    primitive-ref primitive-set!
+    $fx= $fx< $fx<= $fx> $fx>= $fxzero?
+    $fx+ $fx- $fx* $fxadd1 $fxsub1 $fxquotient $fxremainder $fxmodulo 
+    $fxsll $fxsra $fxlognot $fxlogor $fxlogand $fxlogxor
+    $fixnum->char $char->fixnum
+    $char= $char< $char<= $char> $char>=
+    $car $cdr $set-car! $set-cdr!
+    $make-vector $vector-ref $vector-set! $vector-length
+    $make-string $string-ref $string-set! $string-length $string
+    $symbol-string $symbol-unique-string $symbol-value
+    $set-symbol-string! $set-symbol-unique-string! $set-symbol-value!
+    $make-symbol $set-symbol-plist!  $symbol-plist
+    $sc-put-cte 
+    $record? $record/rtd? $record-set! $record-ref $record-rtd
+    $make-record $record
+    $base-rtd
+    $code? $code-reloc-vector $code-freevars $code-size $code-ref $code-set!
+    $code->closure list*->code* 
+    make-code code? set-code-reloc-vector! code-reloc-vector code-freevars
+    code-size code-ref code-set!
+    $frame->continuation $fp-at-base $current-frame $seal-frame-and-call
+    $make-call-with-values-procedure $make-values-procedure
+    do-overflow collect
+    $make-tcbucket $tcbucket-next $tcbucket-key $tcbucket-val
+    $set-tcbucket-next! $set-tcbucket-val! $set-tcbucket-tconc!
+    call/cf trace-symbol! untrace-symbol! make-traced-procedure
+    fixnum->string date-string
+    vector-memq vector-memv
+
+
+
+port?  input-port?  output-port?  $make-input-port make-input-port $make-output-port make-output-port $make-input/output-port make-input/output-port $port-handler port-handler $port-input-buffer port-input-buffer $port-input-index port-input-index $port-input-size port-input-size $port-output-buffer port-output-buffer $port-output-index port-output-index $port-output-size port-output-size $set-port-input-index!  set-port-input-index!  $set-port-input-size!  set-port-input-size!  $set-port-output-index!  set-port-output-index!  $set-port-output-size!  set-port-output-size!  $write-char write-char newline port-name input-port-name output-port-name $read-char read-char $unread-char unread-char $peek-char peek-char $unread-char $reset-input-port!  reset-input-port!  $close-input-port  close-input-port  $close-output-port close-output-port $flush-output-port flush-output-port *standard-input-port* console-input-port *current-input-port* current-input-port *standard-output-port* *current-output-port* *standard-error-port* standard-output-port standard-error-port console-output-port current-output-port *current-output-port* open-output-file open-output-string get-output-string with-output-to-file call-with-output-file with-input-from-file call-with-input-file
+
+    ))
+ 
+
+
+(define (whack-system-env setenv?)
+  (define add-prim
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))])
+        (putprop x '|#system| g)
+        (putprop g '*sc-expander* (cons 'core-primitive x)))))
+  (define add-macro
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))]
+            [e (getprop x '*sc-expander*)])
+        (when e 
+          (putprop x '|#system| g)
+          (putprop g '*sc-expander* e)))))
+  (define (foo)
+    (eval 
+      `(begin
+         (define-syntax compile-time-date-string
+           (lambda (x)
+             #'(quote ,(#%date-string))))
+         (define-syntax public-primitives
+           (lambda (x)
+             #'(quote ,public-primitives)))
+         (define-syntax system-primitives
+           (lambda (x)
+             #'(quote ,system-primitives))) 
+         (define-syntax macros
+           (lambda (x)
+             #'(quote ,macros))))))
+  (set! system-env ($make-environment '|#system| #t))
+  (for-each add-macro macros)
+  (for-each add-prim public-primitives)
+  (for-each add-prim system-primitives)
+  (if setenv?
+      (parameterize ([interaction-environment system-env])
+        (foo))
+      (foo)))
+
+
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #f)
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.9.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #t)
+  (printf "ok\n")
+  (load "libassembler-compat-6.7.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.7.ss") ; uses code? etc.
+  (load "libcompile-6.7.ss") ; uses fasl-write
+)
+
+
+(whack-system-env #t)
+
+(define scheme-library-files
+  '(["libhandlers-6.9.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.9.ss"        "libcore.fasl"]
+    ["libio-6.9.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"   "libassembler.ss"]
+    ["libintelasm-6.9.ss"    "libintelasm.fasl"]
+    ["libfasl-6.7.ss"        "libfasl.fasl"]
+    ["libcompile-6.7.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.9.ss"    "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+    ["libtrace-6.9.ss"       "libtrace.fasl"]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.9.ss"    "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] 
+                 [expand-mode 'bootstrap]
+                 [interaction-environment system-env])
+     (printf "compiling ~a ...\n" ifile)
+     (compile-file ifile ofile 'replace)))
+
+(for-each 
+  (lambda (x)
+    (compile-library (car x) (cadr x)))
+  scheme-library-files)
+
+
+(define (join s ls)
+  (cond
+    [(null? ls) ""]
+    [else
+     (let ([str (open-output-string)])
+       (let f ([a (car ls)] [d (cdr ls)])
+         (cond
+           [(null? d)
+            (display a str)
+            (get-output-string str)]
+           [else
+            (display a str)
+            (display s str)
+            (f (car d) (cdr d))])))]))
+   
+
+(system
+  (format "cat ~a > ikarus.fasl"
+          (join " " (map cadr scheme-library-files))))
diff --git a/src/compiler-8.1.ss b/src/compiler-8.1.ss
new file mode 100644
index 0000000..9480512
--- /dev/null
+++ b/src/compiler-8.1.ss
@@ -0,0 +1,289 @@
+
+
+;;; 8.1: * using chez-style io ports
+;;; 6.9: * creating a *system* environment
+;;; 6.8: * creating a core-primitive form in the expander
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+
+
+
+(define macros
+  '(|#primitive| lambda case-lambda set! quote begin define if letrec
+    foreign-call $apply
+    quasiquote unquote unquote-splicing
+    define-syntax identifier-syntax let-syntax letrec-syntax
+    fluid-let-syntax alias meta eval-when with-implicit with-syntax
+    type-descriptor
+    syntax-case syntax-rules module $module import $import import-only
+    syntax quasisyntax unsyntax unsyntax-splicing datum
+    let let* let-values cond case define-record or and when unless do
+    include parameterize trace untrace trace-lambda))
+
+
+
+(define public-primitives
+  '(null? pair? char? fixnum? symbol? gensym? string? vector? list?
+    boolean? procedure? 
+    not
+    eof-object eof-object? bwp-object?
+    void
+    fx= fx< fx<= fx> fx>= fxzero?
+    fx+ fx- fx* fxadd1 fxsub1 fxquotient fxremainder fxmodulo 
+    fxsll fxsra fxlognot fxlogor fxlogand fxlogxor
+    integer->char char->integer
+    char=? char<? char<=? char>? char>=?
+    cons car cdr set-car! set-cdr!
+    caar cadr cdar cddr 
+    caaar caadr cadar caddr cdaar cdadr cddar cdddr 
+    caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr 
+    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr 
+    list list* make-list length list-ref
+    append
+    make-vector vector-ref vector-set! vector-length vector
+    vector->list list->vector
+    make-string string-ref string-set! string-length string list->string
+    uuid
+    string-append substring 
+    string=? string<? string<=? string>? string>=?
+    remprop putprop getprop property-list
+    apply
+    map for-each andmap ormap
+    memq memv assq 
+    eq? equal?
+    reverse
+    string->symbol symbol->string oblist 
+    top-level-value set-top-level-value! top-level-bound?
+    gensym gensym-count gensym-prefix print-gensym
+    gensym->unique-string
+    call-with-values values
+    make-parameter dynamic-wind
+    display write fasl-write printf format print-error
+    read-token read
+    error exit call/cc
+    current-error-handler
+    eval current-eval interpret compile compile-file new-cafe load
+    system
+    expand sc-expand current-expand expand-mode 
+    environment? interaction-environment
+    identifier? free-identifier=? bound-identifier=? literal-identifier=?
+    datum->syntax-object syntax-object->datum syntax-error
+    syntax->list
+    generate-temporaries
+    record? record-set! record-ref record-length
+    record-type-descriptor make-record-type
+    record-printer record-name record-field-accessor
+    record-field-mutator record-predicate record-constructor
+    record-type-name record-type-symbol record-type-field-names 
+    hash-table? make-hash-table get-hash-table put-hash-table!
+    assembler-output
+    $make-environment
+    features
+
+    port? input-port? output-port? 
+    make-input-port make-output-port make-input/output-port
+    port-handler
+    port-input-buffer port-input-index port-input-size 
+    port-output-buffer port-output-index port-output-size 
+    set-port-input-index! set-port-input-size! 
+    set-port-output-index! set-port-output-size!
+    port-name input-port-name output-port-name
+    write-char read-char unread-char peek-char
+    newline 
+    reset-input-port!  flush-output-port
+    close-input-port close-output-port
+    console-input-port current-input-port
+    standard-output-port standard-error-port
+    console-output-port current-output-port
+    open-output-file
+    open-output-string get-output-string
+    with-output-to-file call-with-output-file
+    with-input-from-file call-with-input-file
+    
+
+    ))
+
+(define system-primitives
+  '(immediate? $unbound-object? $forward-ptr?
+    pointer-value 
+    primitive-ref primitive-set!
+    $fx= $fx< $fx<= $fx> $fx>= $fxzero?
+    $fx+ $fx- $fx* $fxadd1 $fxsub1 $fxquotient $fxremainder $fxmodulo 
+    $fxsll $fxsra $fxlognot $fxlogor $fxlogand $fxlogxor
+    $fixnum->char $char->fixnum
+    $char= $char< $char<= $char> $char>=
+    $car $cdr $set-car! $set-cdr!
+    $make-vector $vector-ref $vector-set! $vector-length
+    $make-string $string-ref $string-set! $string-length $string
+    $symbol-string $symbol-unique-string $symbol-value
+    $set-symbol-string! $set-symbol-unique-string! $set-symbol-value!
+    $make-symbol $set-symbol-plist!  $symbol-plist
+    $sc-put-cte 
+    $record? $record/rtd? $record-set! $record-ref $record-rtd
+    $make-record $record
+    $base-rtd
+    $code? $code-reloc-vector $code-freevars $code-size $code-ref $code-set!
+    $code->closure list*->code* 
+    make-code code? set-code-reloc-vector! code-reloc-vector code-freevars
+    code-size code-ref code-set!
+    $frame->continuation $fp-at-base $current-frame $seal-frame-and-call
+    $make-call-with-values-procedure $make-values-procedure
+    do-overflow collect
+    $make-tcbucket $tcbucket-next $tcbucket-key $tcbucket-val
+    $set-tcbucket-next! $set-tcbucket-val! $set-tcbucket-tconc!
+    call/cf trace-symbol! untrace-symbol! make-traced-procedure
+    fixnum->string date-string
+    vector-memq vector-memv
+
+    ;;; must open-code
+    $make-port
+    $make-input-port $make-output-port $make-input/output-port
+    $port-handler
+    $port-input-buffer $port-input-index $port-input-size 
+    $port-output-buffer $port-output-index $port-output-size 
+    $set-port-input-index! $set-port-input-size!
+    $set-port-output-index! $set-port-output-size!
+
+    ;;; better open-code
+    $write-char $read-char $peek-char $unread-char
+
+    ;;; never open-code 
+    $reset-input-port! $close-input-port
+    $close-output-port $flush-output-port
+    *standard-output-port* *standard-error-port* *current-output-port*
+    *standard-input-port* *current-input-port*
+    ))
+ 
+
+
+(define (whack-system-env setenv?)
+  (define add-prim
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))])
+        (putprop x '|#system| g)
+        (putprop g '*sc-expander* (cons 'core-primitive x)))))
+  (define add-macro
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))]
+            [e (getprop x '*sc-expander*)])
+        (when e 
+          (putprop x '|#system| g)
+          (putprop g '*sc-expander* e)))))
+  (define (foo)
+    (eval 
+      `(begin
+         (define-syntax compile-time-date-string
+           (lambda (x)
+             #'(quote ,(#%date-string))))
+         (define-syntax public-primitives
+           (lambda (x)
+             #'(quote ,public-primitives)))
+         (define-syntax system-primitives
+           (lambda (x)
+             #'(quote ,system-primitives))) 
+         (define-syntax macros
+           (lambda (x)
+             #'(quote ,macros))))))
+  (set! system-env ($make-environment '|#system| #t))
+  (for-each add-macro macros)
+  (for-each add-prim public-primitives)
+  (for-each add-prim system-primitives)
+  (if setenv?
+      (parameterize ([interaction-environment system-env])
+        (foo))
+      (foo)))
+
+
+
+(when (eq? "" "")
+  (load "chez-compat.ss")
+  (set! primitive-ref top-level-value)
+  (set! primitive-set! set-top-level-value!)
+  (set! chez-expand sc-expand)
+  (set! chez-current-expand current-expand)
+  (printf "loading psyntax.pp ...\n")
+  (load "psyntax-7.1.pp")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #f)
+  (printf "loading psyntax.ss ...\n")
+  (load "psyntax-7.1-6.9.ss")
+  (chez-current-expand
+    (lambda (x . args)
+      (apply chez-expand (sc-expand x) args)))
+  (whack-system-env #t)
+  (printf "ok\n")
+  (load "libassembler-compat-6.7.ss") ; defines make-code etc.
+  (load "libintelasm-6.6.ss") ; uses make-code, etc.
+  (load "libfasl-6.7.ss") ; uses code? etc.
+  (load "libcompile-8.1.ss") ; uses fasl-write
+)
+
+
+(whack-system-env #t)
+
+(define scheme-library-files
+  '(["libhandlers-6.9.ss"   #t  "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"    #t  "libcontrol.fasl"]
+    ["libcollect-6.1.ss"    #t  "libcollect.fasl"]
+    ["librecord-6.4.ss"     #t  "librecord.fasl"]
+    ["libcxr-6.0.ss"        #t  "libcxr.fasl"]
+    ["libcore-6.9.ss"       #t  "libcore.fasl"]
+    ["libchezio-8.1.ss"     #t  "libchezio.fasl"]
+    ["libwriter-6.2.ss"     #t  "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"  #t  "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"  #t  "libassembler.ss"]
+    ["libintelasm-6.9.ss"   #t  "libintelasm.fasl"]
+    ["libfasl-6.7.ss"       #t  "libfasl.fasl"]
+    ["libcompile-8.1.ss"    #t  "libcompile.fasl"]
+    ["psyntax-7.1-6.9.ss"   #t  "psyntax.fasl"]
+    ["libinterpret-6.5.ss"  #t  "libinterpret.fasl"]
+    ["libcafe-6.1.ss"       #t  "libcafe.fasl"]
+    ["libtrace-6.9.ss"      #t  "libtrace.fasl"]
+    ["libposix-6.0.ss"      #t  "libposix.fasl"]
+    ["libhash-6.2.ss"       #t  "libhash.fasl"]
+    ["libtoplevel-6.9.ss"   #t  "libtoplevel.fasl"]
+    ))
+
+
+
+(define (compile-library ifile ofile)
+  (parameterize ([assembler-output #f] 
+                 [expand-mode 'bootstrap]
+                 [interaction-environment system-env])
+     (printf "compiling ~a ...\n" ifile)
+     (compile-file ifile ofile 'replace)
+     (printf "done\n")))
+
+(for-each 
+  (lambda (x)
+    (when (cadr x)
+      (compile-library (car x) (caddr x))))
+  scheme-library-files)
+
+
+(define (join s ls)
+  (cond
+    [(null? ls) ""]
+    [else
+     (let ([str (open-output-string)])
+       (let f ([a (car ls)] [d (cdr ls)])
+         (cond
+           [(null? d)
+            (display a str)
+            (get-output-string str)]
+           [else
+            (display a str)
+            (display s str)
+            (f (car d) (cdr d))])))]))
+   
+
+(system
+  (format "cat ~a > ikarus.fasl"
+          (join " " (map caddr scheme-library-files))))
diff --git a/src/geninstr/gen.pl b/src/geninstr/gen.pl
index eeea6cf..188e773 100755
--- a/src/geninstr/gen.pl
+++ b/src/geninstr/gen.pl
@@ -48,7 +48,12 @@ sub gen3{
   }
 }
 
-gen1 "movb \$0, 4(r1)\n";
+gen1 "movl \$0x1234, r1\n";
+
+#gen1 "movl \$27, 4(r1)\n";
+#gen1 "movl \$27, 4000(r1)\n";
+
+#gen1 "movb \$0, 4(r1)\n";
 #gen1 "movb -2(r1), %ah\n";
 
 #gen2 "xorl r1,r2\n";
diff --git a/src/geninstr/tmp.dump b/src/geninstr/tmp.dump
index 7b18d91..d0c65b1 100644
--- a/src/geninstr/tmp.dump
+++ b/src/geninstr/tmp.dump
@@ -4,11 +4,11 @@ tmp.o:     file format elf32-i386
 Disassembly of section .text:
 
 00000000 <.text>:
-   0:	c6 40 04 00          	movb   $0x0,0x4(%eax)
-   4:	c6 41 04 00          	movb   $0x0,0x4(%ecx)
-   8:	c6 42 04 00          	movb   $0x0,0x4(%edx)
-   c:	c6 43 04 00          	movb   $0x0,0x4(%ebx)
-  10:	c6 44 24 04 00       	movb   $0x0,0x4(%esp)
-  15:	c6 45 04 00          	movb   $0x0,0x4(%ebp)
-  19:	c6 46 04 00          	movb   $0x0,0x4(%esi)
-  1d:	c6 47 04 00          	movb   $0x0,0x4(%edi)
+   0:	b8 34 12 00 00       	mov    $0x1234,%eax
+   5:	b9 34 12 00 00       	mov    $0x1234,%ecx
+   a:	ba 34 12 00 00       	mov    $0x1234,%edx
+   f:	bb 34 12 00 00       	mov    $0x1234,%ebx
+  14:	bc 34 12 00 00       	mov    $0x1234,%esp
+  19:	bd 34 12 00 00       	mov    $0x1234,%ebp
+  1e:	be 34 12 00 00       	mov    $0x1234,%esi
+  23:	bf 34 12 00 00       	mov    $0x1234,%edi
diff --git a/src/geninstr/tmp.s b/src/geninstr/tmp.s
index 7d5ea4f..2bc8fb8 100644
--- a/src/geninstr/tmp.s
+++ b/src/geninstr/tmp.s
@@ -1,9 +1,9 @@
 .text
-movb $0, 4(%eax)
-movb $0, 4(%ecx)
-movb $0, 4(%edx)
-movb $0, 4(%ebx)
-movb $0, 4(%esp)
-movb $0, 4(%ebp)
-movb $0, 4(%esi)
-movb $0, 4(%edi)
+movl $0x1234, %eax
+movl $0x1234, %ecx
+movl $0x1234, %edx
+movl $0x1234, %ebx
+movl $0x1234, %esp
+movl $0x1234, %ebp
+movl $0x1234, %esi
+movl $0x1234, %edi
diff --git a/src/ikarus.fasl b/src/ikarus.fasl
index 047aad2..4fad35e 100644
Binary files a/src/ikarus.fasl and b/src/ikarus.fasl differ
diff --git a/src/libassembler-6.7.ss b/src/libassembler-6.7.ss
new file mode 100644
index 0000000..1b734b7
--- /dev/null
+++ b/src/libassembler-6.7.ss
@@ -0,0 +1,56 @@
+
+(primitive-set! 'make-code
+  (lambda (code-size freevars)
+    (unless (and (fixnum? code-size) ($fx>= code-size 0))
+      (error 'make-code "~s is not a valid code size" code-size))
+    (unless (and (fixnum? freevars) ($fx>= freevars 0))
+      (error 'make-code "~s is not a valid number of free vars" freevars))
+    (foreign-call "ikrt_make_code" code-size freevars '#())))
+
+(primitive-set! 'code?
+  (lambda (x) ($code? x)))
+
+(primitive-set! 'code-reloc-vector
+  (lambda (x)
+    (unless ($code? x) (error 'code-reloc-vector "~s is not a code" x))
+    ($code-reloc-vector x)))
+
+(primitive-set! 'code-freevars
+  (lambda (x)
+    (unless ($code? x) (error 'code-closure-size "~s is not a code" x))
+    ($code-freevars x)))
+
+(primitive-set! 'code-size
+  (lambda (x)
+    (unless ($code? x) (error 'code-size "~s is not a code" x))
+    ($code-size x)))
+
+(primitive-set! 'code-set!
+  (lambda (x i v)
+    (unless ($code? x) (error 'code-set! "~s is not a code" x))
+    (unless (and (fixnum? i)
+                 ($fx>= i 0)
+                 ($fx< i ($code-size x)))
+      (error 'code-set! "~s is not a valid index" i))
+    (unless (and (fixnum? v)
+                 ($fx>= v 0)
+                 ($fx< v 256))
+      (error 'code-set! "~s is not a valid byte" v))
+    ($code-set! x i v)))
+
+(primitive-set! 'code-ref
+  (lambda (x i)
+    (unless ($code? x) (error 'code-ref "~s is not a code" x))
+    (unless (and (fixnum? i)
+                 ($fx>= i 0)
+                 ($fx< i ($code-size x)))
+      (error 'code-ref "~s is not a valid index" i))
+    ($code-ref x i)))
+
+(primitive-set! 'set-code-reloc-vector!
+  (lambda (x v)
+    (unless ($code? x) 
+      (error 'set-code-reloc-vector! "~s is not a code" x))
+    (unless (vector? v)
+      (error 'set-code-reloc-vector! "~s is not a vector" v))
+    (foreign-call "ikrt_set_code_reloc_vector" x v)))
diff --git a/src/libassembler-compat-6.0.ss b/src/libassembler-compat-6.0.ss
index 01782f9..2056db0 100644
--- a/src/libassembler-compat-6.0.ss
+++ b/src/libassembler-compat-6.0.ss
@@ -1,56 +1,67 @@
 
-(define-record code (closure-size code-vec reloc-vec))
-
-(define make-code
-  (let ([make-code make-code])
+(let ()
+  (define-record code (closure-size code-vec reloc-vec))
+  
+  (define make-code^
     (lambda (code-size reloc-size closure-size)
       (let ([code-size (fxsll (fxsra (fx+ code-size 3) 2) 2)]) 
         (make-code 
           closure-size
           (make-string code-size (integer->char 0))
-          (make-vector (fxsra reloc-size 2)))))))
+          (make-vector (fxsra reloc-size 2))))))
+  
+  (define set-code-byte! 
+    (lambda (code idx byte)
+      (string-set! (code-code-vec code) idx (integer->char byte))))
+  
+  (define set-code-word!
+    (lambda (code idx x)
+      (cond
+        [(fixnum? x) 
+         (set-code-byte! code (fx+ idx 0) (fxsll (fxlogand x #x3F) 2))
+         (set-code-byte! code (fx+ idx 1) (fxlogand (fxsra x 6) #xFF))
+         (set-code-byte! code (fx+ idx 2) (fxlogand (fxsra x 14) #xFF))
+         (set-code-byte! code (fx+ idx 3) (fxlogand (fxsra x 22) #xFF))]
+        [else (error 'set-code-word! "unhandled ~s" x)])))
+  
+  (define set-code-object!
+    (lambda (code obj code-idx reloc-idx)
+      (let ([v (code-reloc-vec code)])
+        (vector-set! v reloc-idx (list 'object code-idx obj)))))
+  
+  (define set-code-foreign-object!
+    (lambda (code obj code-idx reloc-idx) 
+      (let ([v (code-reloc-vec code)])
+        (vector-set! v reloc-idx (list 'foreign code-idx obj))
+        (vector-set! v (fxadd1 reloc-idx) '(skip)))))
+  
+  (define set-code-object+offset/rel! 
+    (lambda (code obj code-idx obj-idx reloc-idx)
+      (let ([v (code-reloc-vec code)])
+        (vector-set! v reloc-idx 
+          (list 'object+off/rel code-idx obj obj-idx))
+        (vector-set! v (fxadd1 reloc-idx) '(skip)))))
+  
+  (define set-code-object+offset!
+    (lambda (code obj code-idx obj-idx reloc-idx)
+      (let ([v (code-reloc-vec code)])
+        (vector-set! v reloc-idx 
+          (list 'object+off code-idx obj obj-idx))
+        (vector-set! v (fxadd1 reloc-idx) '(skip)))))
+  
+  (define make-code-executable!
+    (lambda (x) (void)))
 
-(define set-code-byte! 
-  (lambda (code idx byte)
-    (string-set! (code-code-vec code) idx (integer->char byte))))
-
-
-(define set-code-word!
-  (lambda (code idx x)
-    (cond
-      [(fixnum? x) 
-       (set-code-byte! code (fx+ idx 0) (fxsll (fxlogand x #x3F) 2))
-       (set-code-byte! code (fx+ idx 1) (fxlogand (fxsra x 6) #xFF))
-       (set-code-byte! code (fx+ idx 2) (fxlogand (fxsra x 14) #xFF))
-       (set-code-byte! code (fx+ idx 3) (fxlogand (fxsra x 22) #xFF))]
-      [else (error 'set-code-word! "unhandled ~s" x)])))
-
-(define set-code-object!
-  (lambda (code obj code-idx reloc-idx)
-    (let ([v (code-reloc-vec code)])
-      (vector-set! v reloc-idx (list 'object code-idx obj)))))
-
-(define set-code-foreign-object!
-  (lambda (code obj code-idx reloc-idx) 
-    (let ([v (code-reloc-vec code)])
-      (vector-set! v reloc-idx (list 'foreign code-idx obj))
-      (vector-set! v (fxadd1 reloc-idx) '(skip)))))
-
-
-(define set-code-object+offset/rel! 
-  (lambda (code obj code-idx obj-idx reloc-idx)
-    (let ([v (code-reloc-vec code)])
-      (vector-set! v reloc-idx 
-        (list 'object+off/rel code-idx obj obj-idx))
-      (vector-set! v (fxadd1 reloc-idx) '(skip)))))
-
-(define set-code-object+offset!
-  (lambda (code obj code-idx obj-idx reloc-idx)
-    (let ([v (code-reloc-vec code)])
-      (vector-set! v reloc-idx 
-        (list 'object+off code-idx obj obj-idx))
-      (vector-set! v (fxadd1 reloc-idx) '(skip)))))
-
-(define make-code-executable!
-  (lambda (x) (void)))
+  (primitive-set! 'make-code                   make-code^)
+  (primitive-set! 'code?                       code?)
+  (primitive-set! 'code-code-vec               code-code-vec)
+  (primitive-set! 'code-reloc-vec              code-reloc-vec)
+  (primitive-set! 'code-closure-size           code-closure-size)
+  (primitive-set! 'set-code-byte!              set-code-byte!) 
+  (primitive-set! 'set-code-word!              set-code-word!)
+  (primitive-set! 'set-code-object!            set-code-object!)
+  (primitive-set! 'set-code-foreign-object!    set-code-foreign-object!)
+  (primitive-set! 'set-code-object+offset/rel! set-code-object+offset/rel!)
+  (primitive-set! 'set-code-object+offset!     set-code-object+offset!)
+  (primitive-set! 'make-code-executable!       make-code-executable!))
 
diff --git a/src/libassembler-compat-6.6.ss b/src/libassembler-compat-6.6.ss
new file mode 100644
index 0000000..3dfffec
--- /dev/null
+++ b/src/libassembler-compat-6.6.ss
@@ -0,0 +1,32 @@
+
+(let ()
+  (define-record code (closure-size code-string reloc-vector))
+  
+  (define make-code^
+    (lambda (code-size closure-size)
+      (let ([code-size (fxsll (fxsra (fx+ code-size 3) 2) 2)]) 
+        (make-code 
+          closure-size
+          (make-string code-size)
+          #f))))
+  
+  (define code-set! 
+    (lambda (code idx byte)
+      (string-set! (code-code-string code) idx (integer->char byte))))
+
+  (define code-ref
+    (lambda (code idx)
+      (char->integer (string-ref (code-code-string code) idx))))
+ 
+  (define (code-size code)
+    (string-length (code-code-string code)))
+
+  (primitive-set! 'make-code                   make-code^)
+  (primitive-set! 'code?                       code?)
+  (primitive-set! 'code-reloc-vector           code-reloc-vector)
+  (primitive-set! 'code-closure-size           code-closure-size)
+  (primitive-set! 'code-size                   code-size)
+  (primitive-set! 'code-set!                   code-set!) 
+  (primitive-set! 'code-ref                    code-ref) 
+  (primitive-set! 'set-code-reloc-vector!      set-code-reloc-vector!))
+
diff --git a/src/libassembler-compat-6.7.ss b/src/libassembler-compat-6.7.ss
new file mode 100644
index 0000000..dd34e27
--- /dev/null
+++ b/src/libassembler-compat-6.7.ss
@@ -0,0 +1,32 @@
+
+(let ()
+  (define-record code (freevars code-string reloc-vector))
+  
+  (define make-code^
+    (lambda (code-size freevars)
+      (let ([code-size (fxsll (fxsra (fx+ code-size 3) 2) 2)]) 
+        (make-code 
+          freevars
+          (make-string code-size)
+          #f))))
+  
+  (define code-set! 
+    (lambda (code idx byte)
+      (string-set! (code-code-string code) idx (integer->char byte))))
+
+  (define code-ref
+    (lambda (code idx)
+      (char->integer (string-ref (code-code-string code) idx))))
+ 
+  (define (code-size code)
+    (string-length (code-code-string code)))
+
+  (primitive-set! 'make-code                   make-code^)
+  (primitive-set! 'code?                       code?)
+  (primitive-set! 'code-reloc-vector           code-reloc-vector)
+  (primitive-set! 'code-freevars               code-freevars)
+  (primitive-set! 'code-size                   code-size)
+  (primitive-set! 'code-set!                   code-set!) 
+  (primitive-set! 'code-ref                    code-ref) 
+  (primitive-set! 'set-code-reloc-vector!      set-code-reloc-vector!))
+
diff --git a/src/libassembler-compat.ss b/src/libassembler-compat.ss
new file mode 100644
index 0000000..12406b2
Binary files /dev/null and b/src/libassembler-compat.ss differ
diff --git a/src/libassembler.ss b/src/libassembler.ss
new file mode 100644
index 0000000..b748820
Binary files /dev/null and b/src/libassembler.ss differ
diff --git a/src/libcafe-6.1.ss b/src/libcafe-6.1.ss
index 25eedff..34cae3c 100644
--- a/src/libcafe-6.1.ss
+++ b/src/libcafe-6.1.ss
@@ -30,7 +30,6 @@
           (with-error-handler
             (lambda args
               (reset-input-port! (console-input-port))
-              (display "repl catch\n" (console-output-port))
               (apply print-error args)
               (k (void)))
             (lambda ()
@@ -64,7 +63,7 @@
 
   (primitive-set! 'new-cafe
     (case-lambda
-      [() (new-cafe (current-eval))]
+      [() (new-cafe eval)]
       [(p)
        (unless (procedure? p) 
          (error 'new-cafe "~s is not a procedure" p))
diff --git a/src/libcafe.fasl b/src/libcafe.fasl
index c4b3966..b36efff 100644
Binary files a/src/libcafe.fasl and b/src/libcafe.fasl differ
diff --git a/src/libchezio-8.1.ss b/src/libchezio-8.1.ss
new file mode 100644
index 0000000..3f577c7
--- /dev/null
+++ b/src/libchezio-8.1.ss
@@ -0,0 +1,750 @@
+
+
+(let ()
+  (include "unsafe-record.ss")
+  ;;;
+  ;;; GENERIC PORTS: BASIC PRIMITIVES
+  ;;;
+  ;;; Exports: 
+  ;;; * Constructors:
+  ;;;   (make-input-port handler input-buffer)
+  ;;;   (make-output-port handler output-buffer)
+  ;;;   (make-input/output-port handler input-buffer output-buffer)
+  ;;;
+  ;;; * Predicates:
+  ;;;   (port? x)
+  ;;;   (input-port? x)
+  ;;;   (output-port? x)
+  ;;;
+  ;;; * Accessors:
+  ;;;   (port-handler port)
+  ;;;   (port-input-buffer port)
+  ;;;   (port-input-index port)
+  ;;;   (port-input-size port)
+  ;;;   (port-output-buffer port)
+  ;;;   (port-output-index port)
+  ;;;   (port-output-size port)
+  ;;;
+  ;;; * Mutators:
+  ;;;   (set-port-input-index! port fixnum)
+  ;;;   (set-port-input-size! port fixnum)
+  ;;;   (set-port-output-index! port fixnum)
+  ;;;   (set-port-output-size! port fixnum)
+  ;;;
+  ;;; (begin
+  ;;;   ;;; uncomment this form to use the compiler's definition
+  ;;;   ;;; of ports; otherwise, ports are represented as vanilla
+  ;;;   ;;; records.
+  ;;;   ($define-record-syntax port 
+  ;;;       (handler input-buffer input-index input-size
+  ;;;                output-buffer output-index output-size))
+  ;;;   (define-syntax port? (identifier-syntax $port?))
+  ;;;   (define-syntax input-port? 
+  ;;;     (syntax-rules ()
+  ;;;       [(_ x) (identifier? #'x)
+  ;;;        (and ($port? x) (string? ($port-input-buffer x)))]))
+  ;;;   (define-syntax output-port? 
+  ;;;     (syntax-rules ()
+  ;;;       [(_ x)  (identifier? #'x)
+  ;;;        (and ($port? x) (string? ($port-output-buffer x)))])))
+  ;;;
+  (primitive-set! 'port?
+    (lambda (x) (port? x)))
+  ;;;
+  (primitive-set! 'input-port?
+    (lambda (x) (input-port? x)))
+  ;;;
+  (primitive-set! 'output-port?
+    (lambda (x) (output-port? x)))
+  ;;;
+  (primitive-set! '$make-input-port
+    (lambda (handler buffer)
+      ($make-port handler buffer 0 ($string-length buffer) #f 0 0)))
+  ;;;
+  (primitive-set! 'make-input-port
+    (lambda (handler buffer)
+      (if (procedure? handler)
+          (if (string? buffer)
+              ($make-input-port handler buffer)
+              (error 'make-input-port "~s is not a string" buffer))
+          (error 'make-input-port "~s is not a procedure" handler))))
+  ;;;
+  (primitive-set! '$make-output-port
+    (lambda (handler buffer)
+      ($make-port handler #f 0 0 buffer 0 ($string-length buffer))))
+  ;;;
+  (primitive-set! 'make-output-port
+    (lambda (handler buffer)
+      (if (procedure? handler)
+          (if (string? buffer)
+              ($make-output-port handler buffer)
+              (error 'make-output-port "~s is not a string" buffer))
+          (error 'make-output-port "~s is not a procedure" handler))))
+  ;;;
+  (primitive-set! '$make-input/output-port
+    (lambda (handler input-buffer output-buffer)
+       ($make-port handler
+                  input-buffer 0 ($string-length input-buffer)
+                  output-buffer 0 ($string-length output-buffer))))
+  (primitive-set! 'make-input/output-port
+    (lambda (handler input-buffer output-buffer)
+      (if (procedure? handler)
+          (if (string? input-buffer)
+              (if (string? output-buffer)
+                  ($make-input/output-port handler input-buffer output-buffer) 
+                  (error 'make-input/output-port 
+                         "~s is not a string"
+                         output-buffer))
+              (error 'make-input/output-port "~s is not a string" input-buffer))
+          (error 'make-input/output-port "~s is not a procedure" handler))))
+  ;;;
+  (primitive-set! '$port-handler
+    (lambda (x) ($port-handler x)))
+  ;;;
+  (primitive-set! 'port-handler
+    (lambda (x)
+      (if (port? x)
+          ($port-handler x)
+          (error 'port-handler "~s is not a port" x))))
+  ;;;
+  (primitive-set! '$port-input-buffer
+    (lambda (x) ($port-input-buffer x)))
+  ;;;
+  (primitive-set! 'port-input-buffer
+    (lambda (x)
+      (if (input-port? x)
+          ($port-input-buffer x)
+          (error 'port-input-buffer "~s is not an input-port" x))))
+  ;;;
+  (primitive-set! '$port-input-index
+    (lambda (x) ($port-input-index x)))
+  ;;;
+  (primitive-set! 'port-input-index
+    (lambda (x)
+      (if (input-port? x)
+          ($port-input-index x)
+          (error 'port-input-index "~s is not an input-port" x))))
+  ;;;
+  (primitive-set! '$port-input-size
+    (lambda (x) ($port-input-size x)))
+  ;;;
+  (primitive-set! 'port-input-size
+    (lambda (x)
+      (if (input-port? x)
+          ($port-input-size x)
+          (error 'port-input-size "~s is not an input-port" x))))
+  ;;;
+  (primitive-set! '$port-output-buffer
+    (lambda (x) ($port-output-buffer x)))
+  ;;;
+  (primitive-set! 'port-output-buffer
+    (lambda (x)
+      (if (output-port? x)
+          ($port-output-buffer x)
+          (error 'port-output-buffer "~s is not an output-port" x))))
+  ;;;
+  (primitive-set! '$port-output-index
+    (lambda (x) ($port-output-index x)))
+  ;;;
+  (primitive-set! 'port-output-index
+    (lambda (x)
+      (if (output-port? x)
+          ($port-output-index x)
+          (error 'port-output-index "~s is not an output-port" x))))
+  ;;;
+  (primitive-set! '$port-output-size
+    (lambda (x) ($port-output-size x)))
+  ;;;
+  (primitive-set! 'port-output-size
+    (lambda (x)
+      (if (output-port? x)
+          ($port-output-size x)
+          (error 'port-output-size "~s is not an output-port" x))))
+  ;;;
+  (primitive-set! '$set-port-input-index!
+    (lambda (p i) ($set-port-input-index! p i)))
+  ;;;
+  (primitive-set! 'set-port-input-index!
+    (lambda (p i)
+      (if (input-port? p)
+          (if (fixnum? i)
+              (if ($fx>= i 0)
+                  (if ($fx<= i ($port-input-size p))
+                      ($set-port-input-index! p i)
+                      (error 'set-port-input-index! "index ~s is too big" i))
+                  (error 'set-port-input-index! "index ~s is negative" i))
+              (error 'set-port-input-index! "~s is not a valid index" i))
+          (error 'set-port-input-index! "~s is not an input-port" p))))
+  ;;;
+  (primitive-set! '$set-port-input-size!
+    (lambda (p i) 
+      ($set-port-input-index! p 0)
+      ($set-port-input-size! p i)))
+  ;;;
+  (primitive-set! 'set-port-input-size!
+    (lambda (p i)
+      (if (input-port? p)
+          (if (fixnum? i)
+              (if ($fx>= i 0)
+                  (if ($fx<= i ($string-length ($port-input-buffer p)))
+                      (begin
+                        ($set-port-input-index! p 0)
+                        ($set-port-input-size! p i))
+                      (error 'set-port-input-size! "size ~s is too big" i))
+                  (error 'set-port-input-size! "size ~s is negative" i))
+              (error 'set-port-input-size! "~s is not a valid size" i))
+          (error 'set-port-input-size! "~s is not an input-port" p))))
+  ;;;
+  (primitive-set! '$set-port-output-index!
+    (lambda (p i) ($set-port-output-index! p i)))
+  ;;;
+  (primitive-set! 'set-port-output-index!
+    (lambda (p i)
+      (if (output-port? p)
+          (if (fixnum? i)
+              (if ($fx>= i 0)
+                  (if ($fx<= i ($port-output-size p))
+                      ($set-port-output-index! p i)
+                      (error 'set-port-output-index! "index ~s is too big" i))
+                  (error 'set-port-output-index! "index ~s is negative" i))
+              (error 'set-port-output-index! "~s is not a valid index" i))
+          (error 'set-port-output-index! "~s is not an output-port" p))))
+  ;;;
+  (primitive-set! '$set-port-output-size!
+    (lambda (p i) 
+      ($set-port-output-index! p 0)
+      ($set-port-output-size! p i)))
+  ;;;
+  (primitive-set! 'set-port-output-size!
+    (lambda (p i)
+      (if (output-port? p)
+          (if (fixnum? i)
+              (if ($fx>= i 0)
+                  (if ($fx<= i ($string-length ($port-output-buffer p)))
+                      (begin
+                        ($set-port-output-index! p 0)
+                        ($set-port-output-size! p i))
+                      (error 'set-port-output-size! "size ~s is too big" i))
+                  (error 'set-port-output-size! "size ~s is negative" i))
+              (error 'set-port-output-size! "~s is not a valid size" i))
+          (error 'set-port-output-size! "~s is not an output-port" p)))))
+
+
+(let ()
+  ;;; IO PRIMITIVES
+  ;;;
+  (primitive-set! '$write-char
+    (lambda (c p)
+      (let ([idx ($port-output-index p)])
+        (if ($fx< idx ($port-output-size p))
+            (begin
+              ($string-set! ($port-output-buffer p) idx c)
+              ($set-port-output-index! p ($fxadd1 idx)))
+            (($port-handler p) 'write-char c p)))))
+  ;;;
+  (primitive-set! 'write-char
+    (case-lambda
+      [(c)
+       (if (char? c)
+           ($write-char c (current-output-port))
+           (error 'write-char "~s is not a character" c))]
+      [(c p)
+       (if (char? c)
+           (if (output-port? p)
+               ($write-char c p)
+               (error 'write-char "~s is not an output-port" p))
+           (error 'write-char "~s is not a character" c))]))
+  ;;;
+  (primitive-set! 'newline
+    (case-lambda
+      [() 
+       ($write-char #\newline (current-output-port))
+       ($flush-output-port (current-output-port))]
+      [(p) 
+       (if (output-port? p)
+           (begin
+             ($write-char #\newline p)
+             ($flush-output-port p))
+           (error 'newline "~s is not an output port" p))]))
+  ;;;
+  (primitive-set! 'port-name
+    (lambda (p)
+      (if (port? p) 
+          (($port-handler p) 'port-name p)
+          (error 'port-name "~s is not a port" p))))
+  (primitive-set! 'input-port-name port-name)
+  (primitive-set! 'output-port-name port-name)
+  (primitive-set! '$read-char
+    (lambda (p)
+      (let ([idx ($port-input-index p)])
+        (if ($fx< idx ($port-input-size p))
+            (begin
+              ($set-port-input-index! p ($fxadd1 idx))
+              ($string-ref ($port-input-buffer p) idx))
+            (begin
+              (($port-handler p) 'read-char p))))))
+  ;;;
+  (primitive-set! 'read-char
+    (case-lambda
+      [() ($read-char (current-input-port))]
+      [(p)
+       (if (input-port? p)
+           ($read-char p)
+           (error 'read-char "~s is not an input-port" p))]))
+  ;;;
+  (primitive-set! '$unread-char
+    (lambda (c p)
+      (let ([idx ($fxsub1 ($port-input-index p))])
+        (if (and ($fx>= idx 0)
+                 ($fx< idx ($port-input-size p)))
+            (begin
+              ($set-port-input-index! p idx)
+              ($string-set! ($port-input-buffer p) idx c))
+            (($port-handler p) 'unread-char c p)))))
+  ;;;
+  (primitive-set! 'unread-char
+    (case-lambda
+      [(c) (if (char? c)
+               ($unread-char c (current-input-port))
+               (error 'unread-char "~s is not a character" c))]
+      [(c p)
+       (if (input-port? p)
+           (if (char? c)
+               ($unread-char c p)
+               (error 'unread-char "~s is not a character" c))
+           (error 'unread-char "~s is not an input-port" p))]))
+  ;;;
+  (primitive-set! '$peek-char
+    (lambda (p)
+      (let ([idx ($port-input-index p)])
+        (if ($fx< idx ($port-input-size p))
+            ($string-ref ($port-input-buffer p) idx)
+            (($port-handler p) 'peek-char p)))))
+  ;;;
+  (primitive-set! 'peek-char
+    (case-lambda
+      [() ($peek-char (current-input-port))]
+      [(p)
+       (if (input-port? p)
+           ($peek-char p)
+           (error 'peek-char "~s is not an input-port" p))]))
+  ;;;
+  (primitive-set! '$unread-char
+    (lambda (c p)
+      (let ([idx ($fxsub1 ($port-input-index p))])
+        (if (and ($fx>= idx 0)
+                 ($fx< idx ($port-input-size p)))
+            (begin
+              ($set-port-input-index! p idx)
+              ($string-set! ($port-input-buffer p) idx c))
+            (($port-handler p) 'unread-char c p)))))
+  ;;;
+  (primitive-set! '$reset-input-port!
+    (lambda (p)
+      ($set-port-input-size! p 0)))
+  ;;;
+  (primitive-set! 'reset-input-port!
+    (case-lambda
+      [() ($reset-input-port! (current-input-port))]
+      [(p)
+       (if (input-port? p)
+           ($reset-input-port! p)
+           (error 'reset-input-port! "~s is not an input-port" p))]))
+  ;;;
+  (primitive-set! '$close-input-port
+    (lambda (p)
+      (($port-handler p) 'close-port p)))
+  ;;;
+  (primitive-set! 'close-input-port
+    (case-lambda
+      [() ($close-input-port (current-input-port))]
+      [(p)
+       (if (input-port? p)
+           ($close-input-port p)
+           (error 'close-input-port! "~s is not an input-port" p))]))
+  ;;;
+  (primitive-set! '$close-output-port
+    (lambda (p)
+      (($port-handler p) 'close-port p)))
+  ;;;
+  (primitive-set! 'close-output-port
+    (case-lambda
+      [() ($close-output-port (current-output-port))]
+      [(p)
+       (if (output-port? p)
+           ($close-output-port p)
+           (error 'close-output-port "~s is not an output-port" p))]))
+  ;;;
+  (primitive-set! '$flush-output-port
+    (lambda (p)
+      (($port-handler p) 'flush-output-port p)))
+  ;;;
+  (primitive-set! 'flush-output-port
+    (case-lambda
+      [() ($flush-output-port (current-output-port))]
+      [(p)
+       (if (output-port? p)
+           ($flush-output-port p)
+           (error 'flush-output-port "~s is not an output-port" p))])))
+
+
+
+(let ()
+  ;;; INPUT FILES
+  (include "message-case.ss")
+  (define make-input-file-handler
+    (lambda (fd port-name)
+      (let ((open? #t))
+        (lambda (msg . args)
+          (message-case msg args
+            [(read-char p)
+             (unless (input-port? p)
+               (error 'read-char "~s is not an input port" p))
+             (let ([idx ($port-input-index p)])
+               (if ($fx< idx ($port-input-size p))
+                   (begin
+                     ($set-port-input-index! p ($fxadd1 idx))
+                     ($string-ref ($port-input-buffer p) idx))
+                   (if open?
+                       (let ([bytes
+                              (foreign-call "ikrt_read" fd
+                                            ($port-input-buffer p))])
+                         (cond
+                           [(not bytes)
+                            (error 'read-char "Cannot read from ~s" port-name)]
+                           [($fx= bytes 0)
+                            (eof-object)]
+                           [else
+                            ($set-port-input-size! p bytes)
+                            ($read-char p)]))
+                       (error 'read-char "port ~s is closed" p))))]
+            [(peek-char p)
+             (unless (input-port? p)
+               (error 'peek-char "~s is not an input port" p))
+             (let ([idx ($port-input-index p)])
+               (if ($fx< idx ($port-input-size p))
+                   ($string-ref ($port-input-buffer p) idx)
+                   (if open?
+                       (let ([bytes
+                              (foreign-call "ikrt_read" fd
+                                            (port-input-buffer p))])
+                         (cond
+                           [(not bytes)
+                            (error 'peek-char
+                                   "Cannot read from ~s" port-name)]
+                           [($fx= bytes 0)
+                            (eof-object)]
+                           [else
+                            ($set-port-input-size! p bytes)
+                            ($peek-char p)]))
+                       (error 'peek-char "port ~s is closed" p))))]
+            [(unread-char c p)
+             (unless (input-port? p)
+               (error 'unread-char "~s is not an input port" p))
+             (let ([idx ($fxsub1 ($port-input-index p))])
+               (if (and ($fx>= idx 0)
+                        ($fx< idx ($port-input-size p)))
+                   (begin
+                     ($set-port-input-index! p idx)
+                     ($string-set! ($port-input-buffer p) idx c))
+                   (if open?
+                       (error 'unread-char "port ~s is closed" p)
+                       (error 'unread-char "too many unread-chars"))))]
+            [(port-name p) port-name]
+            [(close-port p)
+             (unless (input-port? p)
+               (error 'close-input-port "~s is not an input port" p))
+             (when open?
+               ($set-port-input-size! p 0)
+               (set! open? #f)
+               (unless (foreign-call "ikrt_close_file" fd)
+                  (error 'close-input-port "cannot close ~s" port-name)))]
+            [else 
+             (error 'input-file-handler
+                    "message not handled ~s" (cons msg args))])))))
+  (define open-input-file
+    (lambda (filename)
+      (let ([fd/error (foreign-call "ikrt_open_input_file" filename)])
+        (if (fixnum? fd/error)
+            (let ([port (make-input-port 
+                          (make-input-file-handler fd/error filename)
+                          (make-string 4096))])
+              (set-port-input-size! port 0)
+              port)
+            (error 'open-input-file "cannot open ~s: ~a" filename fd/error)))))
+  (primitive-set! '*standard-input-port* 
+    (let ([p (make-input-port 
+               (make-input-file-handler 0 '*stdin*)
+               (make-string 4096))])
+      (set-port-input-size! p 0)
+      p))
+  (primitive-set! 'console-input-port (lambda () *standard-input-port*))
+  (primitive-set! '*current-input-port* *standard-input-port*)
+  (primitive-set! 'current-input-port 
+    (case-lambda
+      [() *current-input-port*]
+      [(p) 
+       (if (input-port? p)
+           (primitive-set! '*current-input-port* p)
+           (error 'current-input-port "~s is not an input-port" p))]))
+  (primitive-set! 'open-input-file
+    (lambda (filename)
+       (if (string? filename)
+           (open-input-file filename)
+           (error 'open-input-file "~s is not a string" filename)))))
+
+
+(let ()
+  ;;; OUTPUT FILES
+  (include "message-case.ss")
+  (define do-write-buffer
+    (lambda (fd port-name p caller)
+      (let ([bytes (foreign-call "ikrt_write_file" 
+                                 fd
+                                 (port-output-buffer p)
+                                 (port-output-index p))])
+        (if (fixnum? bytes)
+            (set-port-output-index! p 0)
+            (error caller "cannot write to file ~s: ~a" port-name bytes)))))
+  (define make-output-file-handler
+    (lambda (fd port-name)
+      (define open? #t)
+      (define output-file-handler
+        (lambda (msg . args)
+          (message-case msg args
+            [(write-char c p)
+             (if (char? c)
+                 (if (output-port? p)
+                     (let ([idx ($port-output-index p)])
+                        (if ($fx< idx ($port-output-size p))
+                            (begin
+                              ($string-set! ($port-output-buffer p) idx c)
+                              ($set-port-output-index! p ($fxadd1 idx)))
+                            (if open?
+                              (begin
+                                (do-write-buffer fd port-name p 'write-char)
+                                ($write-char c p))
+                              (error 'write-char "port ~s is closed" p))))
+                     (error 'write-char "~s is not an output-port" p))
+                 (error 'write-char "~s is not a character" c))]
+            [(flush-output-port p)
+             (if (output-port? p)
+                 (if open?
+                     (do-write-buffer fd port-name p 'flush-output-port)
+                     (error 'flush-output-port "port ~s is closed" p))
+                 (error 'flush-output-port "~s is not an output-port" p))]
+            [(close-port p)
+             (when open?
+               (flush-output-port p)
+               ($set-port-output-size! p 0)
+               (set! open? #f)
+               (unless (foreign-call "ikrt_close_file" fd)
+                 (error 'close-output-port "cannot close ~s" port-name)))]
+            [(port-name p) port-name]
+            [else (error 'output-file-handler 
+                         "unhandled message ~s" (cons msg args))])))
+      output-file-handler))
+  (define (option-id x)
+    (case x
+      [(error)    0]
+      [(replace)  1]
+      [(truncate) 2]
+      [(append)   3]
+      [else (error 'open-output-file "~s is not a valid mode" x)]))
+  (define open-output-file
+    (lambda (filename options)
+      (let ([fd/error 
+             (foreign-call "ikrt_open_output_file" 
+                           filename 
+                           (option-id options))])
+        (if (fixnum? fd/error)
+            (make-output-port
+              (make-output-file-handler fd/error filename)
+              (make-string 4096))
+            (error 'open-output-file "cannot open ~s: ~a" filename fd/error)))))
+  (primitive-set! '*standard-output-port* 
+    (make-output-port
+      (make-output-file-handler 1 '*stdout*)
+      (make-string 4096)))
+  (primitive-set! '*current-output-port* *standard-output-port*)
+  (primitive-set! '*standard-error-port* 
+    (make-output-port
+      (make-output-file-handler 2 '*stderr*)
+      (make-string 4096)))
+  (primitive-set! 'standard-output-port 
+     (lambda () *standard-output-port*))
+  (primitive-set! 'standard-error-port
+     (lambda () *standard-error-port*))
+  (primitive-set! 'console-output-port 
+     (lambda () *standard-output-port*))
+  (primitive-set! 'current-output-port 
+     (case-lambda
+       [() *current-output-port*]
+       [(p)
+        (if (output-port? p)
+            (primitive-set! '*current-output-port* p)
+            (error 'current-output-port "~s is not an output port" p))]))
+  (primitive-set! 'open-output-file 
+    (case-lambda
+      [(filename)
+       (if (string? filename)
+           (open-output-file filename 'error)
+           (error 'open-output-file "~s is not a string" filename))]
+      [(filename options)
+       (if (string? filename)
+           (open-output-file filename options)
+           (error 'open-output-file "~s is not a string" filename))])))
+
+
+(let ()
+  (include "message-case.ss")
+  ;;; OUTPUT STRINGS
+  (define string-copy 
+    (lambda (s)
+      (substring s 0 (string-length s))))
+  (define concat 
+    (lambda (str i ls)
+      (let ([n (sum i ls)])
+        (let ([outstr ($make-string n)])
+          (let f ([n (copy outstr str i n)] [ls ls])
+            (if (null? ls)
+                outstr
+                (let ([a ($car ls)])
+                  (f (copy outstr a ($string-length a) n) ($cdr ls)))))))))
+  (define sum 
+    (lambda (ac ls)
+      (cond
+        [(null? ls) ac]
+        [else (sum ($fx+ ac ($string-length ($car ls))) ($cdr ls))])))
+  (define copy
+    (lambda (dst src n end)
+      (let f ([di end]
+              [si n])
+        (cond
+          [($fx= si 0) di]
+          [else
+           (let ([di ($fxsub1 di)] [si ($fxsub1 si)])
+             ($string-set! dst di ($string-ref src si))
+             (f di si))]))))
+  (define make-output-string-handler
+    (lambda ()
+      (define buffer-list '())
+      (define open? #t)
+      (define output-handler
+        (lambda (msg . args)
+          (message-case msg args
+            [(write-char c p)
+             (if (char? c)
+                 (if (output-port? p)
+                     (let ([idx ($port-output-index p)])
+                        (if ($fx< idx ($port-output-size p))
+                            (begin
+                              ($string-set! ($port-output-buffer p) idx c)
+                              ($set-port-output-index! p ($fxadd1 idx)))
+                            (if open?
+                              (begin
+                                (set! buffer-list
+                                  (cons (string-copy (port-output-buffer p))
+                                        buffer-list))
+                                ($set-port-output-size! p 
+                                  ($string-length ($port-output-buffer p)))
+                                ($write-char c p))
+                              (error 'write-char "port ~s is closed" p))))
+                     (error 'write-char "~s is not an output-port" p))
+                 (error 'write-char "~s is not a character" c))]
+            [(flush-output-port p)
+             (void)]
+            [(close-port p)
+             (set! open? #f)]
+            [(port-name p) 'string-port]
+            [(get-output-string p) 
+             (concat ($port-output-buffer p)
+                     ($port-output-index p)
+                     buffer-list)]
+            [else (error 'output-handler 
+                         "unhandled message ~s" (cons msg args))])))
+      output-handler))
+  (primitive-set! 'open-output-string 
+    (lambda ()
+      (make-output-port 
+        (make-output-string-handler)
+        (make-string 10))))
+  (primitive-set! 'get-output-string
+    (lambda (p)
+      (if (output-port? p)
+          (($port-handler p) 'get-output-string p)
+          (error 'get-output-string "~s is not an output port" p))))
+)
+
+(primitive-set! 'with-output-to-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'with-output-to-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'with-output-to-file "~s is not a procedure" proc))
+     (let ([p (apply open-output-file name args)]
+           [shot #f])
+       (parameterize ([current-output-port p])
+         (dynamic-wind 
+           (lambda () 
+             (when shot
+               (error 'with-output-to-file 
+                      "cannot reenter")))
+           proc
+           (lambda () 
+             (close-output-port p)
+             (set! shot #t)))))))
+
+(primitive-set! 'call-with-output-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'call-with-output-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'call-with-output-file "~s is not a procedure" proc))
+     (let ([p (apply open-output-file name args)]
+           [shot #f])
+       (dynamic-wind 
+         (lambda () 
+           (when shot
+             (error 'call-with-output-file "cannot reenter")))
+         (lambda () (proc p))
+         (lambda () 
+           (close-output-port p)
+           (set! shot #t))))))
+
+(primitive-set! 'with-input-from-file
+   (lambda (name proc)
+     (unless (string? name) 
+       (error 'with-input-from-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'with-input-from-file "~s is not a procedure" proc))
+     (let ([p (open-input-file name)]
+           [shot #f])
+       (parameterize ([current-input-port p])
+         (dynamic-wind 
+           (lambda () 
+             (when shot
+               (error 'with-input-from-file 
+                      "cannot reenter")))
+           proc
+           (lambda () 
+             (close-input-port p)
+             (set! shot #t)))))))
+
+(primitive-set! 'call-with-input-file
+   (lambda (name proc)
+     (unless (string? name) 
+       (error 'call-with-input-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'call-with-input-file "~s is not a procedure" proc))
+     (let ([p (open-input-file name)]
+           [shot #f])
+       (dynamic-wind 
+         (lambda () 
+           (when shot
+             (error 'call-with-input-file "cannot reenter")))
+         (lambda () (proc p))
+         (lambda () 
+           (close-input-port p)
+           (set! shot #t))))))
+
diff --git a/src/libcollect.fasl b/src/libcollect.fasl
index 195ddc3..3491553 100644
Binary files a/src/libcollect.fasl and b/src/libcollect.fasl differ
diff --git a/src/libcompile-6.4.ss b/src/libcompile-6.4.ss
new file mode 100644
index 0000000..2bb199a
--- /dev/null
+++ b/src/libcompile-6.4.ss
@@ -0,0 +1,3035 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(let ()
+
+(include "record-case.ss")
+
+
+(include "set-operations.ss")
+
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    ;;;
+    ;;; asm
+    ;;;
+    ;[code?              1    pred]
+    ;[$code-instr-size   1    value]
+    ;[$code-reloc-size   1    value]
+    ;[$code-closure-size 1    value]
+    ;[$code->closure     1    value]
+    ;[$set-code-byte!    3    effect]
+    ;[$set-code-word!    3    effect]
+    ;[$set-code-object!  4    effect]
+    ;[$set-code-object+offset!  5    effect]
+    ;[$set-code-object+offset/rel!  5    effect]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+
+;;; primitives table section
+(define primitives-table
+ '(;;; system locations used by the C/Scheme interface
+   [$apply-nonprocedure-error-handler library]
+   [$incorrect-args-error-handler     library]
+   [$multiple-values-error            library]
+   [$intern                           library]
+   [do-overflow                       library]
+   [do-vararg-overflow                library]
+   [do-stack-overflow                 library]
+   ;;; type predicates
+   [fixnum?                 public]
+   [immediate?              public]
+   [boolean?                public]
+   [char?                   public]
+   [null?                   public]
+   [pair?                   public]
+   [symbol?                 public]
+   [vector?                 public]
+   [string?                 public]
+   [procedure?              public]
+   [eof-object?             public]
+   [not                     public]
+   [eq?                     public]
+   [equal?                  public]
+   ;;; fixnum primitives
+   [fxadd1                  public]
+   [fxsub1                  public]
+   [fx+                     public]
+   [fx-                     public]
+   [fx*                     public]
+   [fxsll                   public]
+   [fxsra                   public]
+   [fxlogor                 public]
+   [fxlogand                public]
+   [fxlogxor                public]
+   [fxlognot                public]
+   [fxquotient              public]
+   [fxremainder             public]
+   [fxmodulo                public]
+   ;;; fixnum predicates
+   [fxzero?                 public]
+   [fx=                     public]
+   [fx<                     public]
+   [fx<=                    public]
+   [fx>                     public]
+   [fx>=                    public]
+   ;;; characters
+   [char=?                  public]
+   [char<?                  public]
+   [char<=?                 public]
+   [char>?                  public]
+   [char>=?                 public]
+   [integer->char           public]
+   [char->integer           public]
+   ;;; lists
+   [cons                    public]
+   [car                     public]
+   [cdr                     public]
+   [caar                    public]
+   [cadr                    public]
+   [cdar                    public]
+   [cddr                    public]
+   [caaar                   public]
+   [caadr                   public]
+   [cadar                   public]
+   [caddr                   public]
+   [cdaar                   public]
+   [cdadr                   public]
+   [cddar                   public]
+   [cdddr                   public]
+   [caaaar                  public]
+   [caaadr                  public]
+   [caadar                  public]
+   [caaddr                  public]
+   [cadaar                  public]
+   [cadadr                  public]
+   [caddar                  public]
+   [cadddr                  public]
+   [cdaaar                  public]
+   [cdaadr                  public]
+   [cdadar                  public]
+   [cdaddr                  public]
+   [cddaar                  public]
+   [cddadr                  public]
+   [cdddar                  public]
+   [cddddr                  public]
+   [set-car!                public]
+   [set-cdr!                public]
+   [list                    public]
+   [list*                   ADDME]
+   [list?                   public]
+   [list-ref                public]
+   [length                  public]
+   [make-list               public]
+   [reverse                 public]
+   [append                  public]
+   [list-ref                public]
+   [memq                    public]
+   [memv                    public]
+   [assq                    public]
+   [map                     public]
+   [for-each                public]
+   [andmap                  public]
+   [ormap                   public]
+   ;;; vectors
+   [make-vector             public]
+   [vector                  public]
+   [vector-length           public]
+   [vector-ref              public]
+   [vector-set!             public]
+   [list->vector            public]
+   [vector->list            public]
+   ;;; strings
+   [make-string             public]
+   [string                  public]
+   [string-length           public]
+   [string-ref              public]
+   [string-set!             public]
+   [list->string            public]
+   [string->list            public]
+   [string-append           public]
+   [substring               public]
+   [string=?                public]
+   [fixnum->string          public]
+   ;;; symbols
+   [gensym                  public]
+   [gensym?                 public]
+   [symbol->string          public]
+   [gensym->unique-string   public]
+   [gensym-prefix           public]
+   [gensym-count            public]
+   [print-gensym            public]
+   [string->symbol          public]
+   [top-level-value         public]
+   [top-level-bound?        public]
+   [set-top-level-value!    public]
+   [primitive-set!          public]
+   [getprop                 public]
+   [putprop                 public]
+   [remprop                 public]
+   [property-list           public]
+   [oblist                  public]
+   [uuid                    public]
+   ;;; eof
+   [eof-object              public]
+   [void                    public]
+   ;;; control/debugging
+   [print-error             public]
+   [error                   public]
+   [current-error-handler   public]
+   [exit                    public]
+   [apply                   public]
+   [make-parameter          public]
+   ;;; output
+   [output-port?            public]
+   [console-output-port     public]
+   [current-output-port     public]
+   [standard-output-port    public]
+   [standard-error-port     public]
+   [open-output-file        public]
+   [open-output-string      public]
+   [with-output-to-file     public]
+   [call-with-output-file   public]
+   [with-input-from-file    public]
+   [call-with-input-file    public]
+   [get-output-string       public]
+   [close-output-port       public]
+   [flush-output-port       public]
+   [write-char              public]
+   [output-port-name        public]
+   [newline                 public]
+   ;;; input
+   [input-port?             public]
+   [standard-input-port     public]
+   [console-input-port      public]
+   [current-input-port      public]
+   [open-input-file         public]
+   [close-input-port        public]
+   [reset-input-port!       public]
+   [read-char               public]
+   [peek-char               public]
+   [unread-char             public]
+   [input-port-name         public]
+   ;;; writing/printing
+   [write                   public]
+   [display                 public]
+   [printf                  public]
+   [fprintf                 public]
+   [format                  public]
+   [read-token              public]
+   [read                    public]
+   ;;; evaluation
+   [primitive?               public]
+   [expand                  public]
+   [syntax-error            public]
+   [current-expand          public]
+   [expand-mode             public]
+   [assembler-output        public]
+   [compile-file            public]
+   [fasl-write              public]
+
+   [$sc-put-cte   public]
+   [sc-expand   public]
+   [$make-environment   public]
+   [environment?   public]
+   [interaction-environment   public]
+   [identifier?   public]
+   [syntax->list   public]
+   [syntax-object->datum   public]
+   [datum->syntax-object   public]
+   [generate-temporaries   public]
+   [free-identifier=?   public]
+   [bound-identifier=?   public]
+   [literal-identifier=?   public]
+   [syntax-error   public]
+   [$syntax-dispatch   public]
+
+
+
+   [interpret               public]
+   [eval                    public]
+   [current-eval            public]
+   [load                    public]
+   [new-cafe                public]
+   [collect                 public]
+   [call/cc                 public]
+   [call/cf                 library]
+   [dynamic-wind            public]
+   [values                  public]
+   [call-with-values        public]
+   [make-traced-procedure   library]
+   [trace-symbol!           library]
+   [untrace-symbol!         library]
+   ;;; record
+   [$base-rtd               library]
+   [record?                 public]
+   [record-rtd              public]
+   [record-name             public]
+   [record-printer          public]
+   [record-length           public]
+   [record-ref              public]
+   [record-set!             public]
+   ;;; record rtds
+   [make-record-type        public]
+   [record-type-name        public]
+   [record-type-descriptor  public]
+   [record-type-symbol      public]
+   [record-type-field-names public]
+   [record-constructor      public]
+   [record-predicate        public]
+   [record-field-accessor   public]
+   [record-field-mutator    public]
+   ;;; hash tables
+   [make-hash-table         public]
+   [hash-table?             public]
+   [get-hash-table          public]
+   [put-hash-table!         public]
+   ;;; asm
+   [make-code               public]
+   [code?                   public]
+   [make-code-executable!   public]
+   [code-instr-size         public]
+   [code-reloc-size         public]
+   [code-closure-size       public]
+   [set-code-byte!          public]
+   [set-code-word!          public]
+   [set-code-object!        public]
+   [set-code-foreign-object!        public]
+   [set-code-object+offset! public]
+   [set-code-object+offset/rel! public]
+   [set-code-object/reloc/relative!  public]
+   [code-reloc-vec          public]
+   [code-code-vec           public]
+   [code->closure           public]
+   [list*->code*            library]
+   ;;;
+   ;;; POSIX
+   ;;;
+   [fork                    public]
+   [posix-fork              public]
+   [system                  public]
+   [$debug                      public]
+   [$underflow-misaligned-error public]
+   ))
+
+
+(define (primitive? x)
+  (cond
+    [(assq x primitives-table) #t]
+    [(assq x open-coded-primitives) #t]
+    [else #f]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [(assq x primitives-table) #f]
+    [else (error 'open-codeable "invalid primitive ~s" x)]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record seq (e0 e1))
+(define-record function (arg* proper body))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define unique-var
+  (let ([counter 0])
+    (lambda (x)
+      (let ([g (gensym (format "~a:~a" x counter))])
+        (set! counter (fxadd1 counter))
+        (make-var g)))))
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (if (primitive? var)
+                (make-primref var)
+                (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (cond
+              [(primitive? var) (make-primref var)]
+              [else (error 'recordize "invalid top-level var ~s" var)]))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(function args proper body)
+       `(lambda ,(E-args proper args) ,(E body))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+;      [(function fml* proper body)
+;       (cond
+;         [proper 
+;          (if (fx= (length fml*) (length rand*))
+;              (make-bind fml* rand* body)
+;              (begin
+;                (warning 'compile "possible application error in ~s"
+;                         (unparse (make-funcall rator rand*)))
+;                (make-funcall rator rand*)))]
+;         [else
+;          (if (fx<= (length fml*) (length rand*))
+;              (make-bind fml* (properize fml* rand*) body)
+;              (begin
+;                (warning 'compile "possible application error in ~s"
+;                         (unparse (make-funcall rator rand*)))
+;                (make-funcall rator rand*)))])]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(function fml* proper body) 
+       (make-function fml* proper (Expr body))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) '()]
+      [else (union (Expr (car x*)) (Expr* (cdr x*)))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) '()]
+      [(var) '()]
+      [(primref) '()]
+      [(bind lhs* rhs* body)
+       (union (Expr body) (Expr* rhs*))]
+      [(conditional test conseq altern)
+       (union (Expr test) (union (Expr conseq) (Expr altern)))]
+      [(seq e0 e1) (union (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (Expr* (map clambda-case-body cls*))]
+      [(function fml* proper body) (Expr body)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (union (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (union (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (union (singleton lhs) (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+(define (rewrite-assignments assigned x)
+  (define who 'rewrite-assignments)
+  (define (fix lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix (cdr lhs*))])
+           (cond
+             [(memq x assigned) 
+              (let ([t (make-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(memq x assigned) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(function fml* proper body) 
+       (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)]) 
+         (make-function fml* proper 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (memq lhs assigned)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+  (let ([assigned (uncover-assigned x)])
+    (rewrite-assignments assigned x)))
+  
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(function fml* proper body) 
+       (let-values ([(body body-free) (Expr body)])
+         (let ([free (difference body-free fml*)])
+           (values (make-closure (make-code-rec fml* proper free body) free)
+                   free)))]
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? code? $forward-ptr? bwp-object?
+        pointer-value)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-instr-size $code-reloc-size $code-closure-size
+        $set-code-byte! $set-code-word! 
+        $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+        $make-record $record? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (simplify* arg* '() '()
+         (lambda (arg* lhs* rhs*)
+           (make-bind^ lhs* rhs* 
+             (make-primcall op arg*))))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list (make-constant n)))
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure code free*) 
+       (check-const (fx+ disp-closure-data (fx* (length free*) wordsize)) x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(vector)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp #t (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" call-convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (case op
+;         [(values) (make-primcall op (simple* arg* r))]
+         [else (make-return (make-primcall op (simple* arg* r)))])]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'tail live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+         
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag #x2F)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-closuresize   12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+
+  (define record-ptag  5)
+  (define record-pmask 7)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define dirty-word -1))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define (align n)
+    (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [(code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx< i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-instr-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag) 
+         (cons (sall (int fx-shift) eax) ac))]
+     [($code-reloc-size) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-closure-size) 
+       (indirect-ref arg* (fx- disp-code-closuresize vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $set-code-byte! $set-code-word!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? code? 
+       $record? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else
+            (error who "invalid convention ~s for call-cp" call-convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let ([Lf (unique-label)] [Ljoin (unique-label)])
+        (Pred test #f Lf
+          (Effect conseq
+            (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (NonTail val
+           (cons (movl eax (idx->frame-loc i)) ac))]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (NonTail body
+        (cond
+          [check
+           (list* 
+             (movl eax cpr) 
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac)]
+          [else
+           (list* 
+             (movl eax cpr) 
+             ac)]))]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(call-cp call-convention rp-convention idx argc mask)
+      (unless (eq? rp-convention 'tail)
+        (error who "nontail rp (~s) in tail context" rp-convention))
+      (let f ([i 0])
+        (cond
+          [(fx= i argc)
+           (case call-convention
+             [(normal) 
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (tail-indirect-cpr-call)
+                ac)]
+             [(apply)
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (jmp (label SL_apply)) 
+                ac)]
+             [else
+              (error who "invalid conv ~s in tail call-cpr" call-convention)])]
+          [else
+            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+                                   (fx- 0 wordsize)) fpr)
+                         eax)
+                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (fx+ disp-closure-data (fx* wordsize (length free)))
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(module ()
+(list*->code*
+  (list
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list disp-closure-data
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list disp-closure-data
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list 
+          (fx+ disp-closure-data wordsize)
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    )))
+
+
+
+(define (compile-expr expr)
+  (let* ([p (recordize expr)]
+         [p (optimize-direct-calls p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (car code*)))
+
+(define compile-file
+  (lambda (input-file output-file . rest)
+    (let ([ip (open-input-file input-file)]
+          [op (apply open-output-file output-file rest)])
+      (let f ()
+        (let ([x (read ip)])
+          (unless (eof-object? x)
+            (fasl-write (compile-expr (expand x)) op)
+            (f))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+(primitive-set! 'compile-file compile-file)
+(primitive-set! 'assembler-output (make-parameter #f))
+)
+
diff --git a/src/libcompile-6.5.ss b/src/libcompile-6.5.ss
new file mode 100644
index 0000000..51dd525
--- /dev/null
+++ b/src/libcompile-6.5.ss
@@ -0,0 +1,3435 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(let ()
+
+(define-syntax cond-expand
+  (lambda (x)
+    (syntax-case x ()
+      [(_ test conseq altern)
+       (if (eval (syntax-object->datum #'test))
+           #'conseq
+           #'altern)])))
+
+(cond-expand (eq? "" "")
+  (include "record-case.chez.ss")
+  (include "record-case.ss"))
+
+
+(include "set-operations.ss")
+
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record/rtd?       2    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    ;;;
+    ;;; asm
+    ;;;
+    ;[code?              1    pred]
+    ;[$code-instr-size   1    value]
+    ;[$code-reloc-size   1    value]
+    ;[$code-closure-size 1    value]
+    ;[$code->closure     1    value]
+    ;[$set-code-byte!    3    effect]
+    ;[$set-code-word!    3    effect]
+    ;[$set-code-object!  4    effect]
+    ;[$set-code-object+offset!  5    effect]
+    ;[$set-code-object+offset/rel!  5    effect]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+
+;;; primitives table section
+(define primitives-table
+ '(;;; system locations used by the C/Scheme interface
+   [$apply-nonprocedure-error-handler library]
+   [$incorrect-args-error-handler     library]
+   [$multiple-values-error            library]
+   [$intern                           library]
+   [do-overflow                       library]
+   [do-vararg-overflow                library]
+   [do-stack-overflow                 library]
+   ;;; type predicates
+   [fixnum?                 public]
+   [immediate?              public]
+   [boolean?                public]
+   [char?                   public]
+   [null?                   public]
+   [pair?                   public]
+   [symbol?                 public]
+   [vector?                 public]
+   [string?                 public]
+   [procedure?              public]
+   [eof-object?             public]
+   [not                     public]
+   [eq?                     public]
+   [equal?                  public]
+   ;;; fixnum primitives
+   [fxadd1                  public]
+   [fxsub1                  public]
+   [fx+                     public]
+   [fx-                     public]
+   [fx*                     public]
+   [fxsll                   public]
+   [fxsra                   public]
+   [fxlogor                 public]
+   [fxlogand                public]
+   [fxlogxor                public]
+   [fxlognot                public]
+   [fxquotient              public]
+   [fxremainder             public]
+   [fxmodulo                public]
+   ;;; fixnum predicates
+   [fxzero?                 public]
+   [fx=                     public]
+   [fx<                     public]
+   [fx<=                    public]
+   [fx>                     public]
+   [fx>=                    public]
+   ;;; characters
+   [char=?                  public]
+   [char<?                  public]
+   [char<=?                 public]
+   [char>?                  public]
+   [char>=?                 public]
+   [integer->char           public]
+   [char->integer           public]
+   ;;; lists
+   [cons                    public]
+   [car                     public]
+   [cdr                     public]
+   [caar                    public]
+   [cadr                    public]
+   [cdar                    public]
+   [cddr                    public]
+   [caaar                   public]
+   [caadr                   public]
+   [cadar                   public]
+   [caddr                   public]
+   [cdaar                   public]
+   [cdadr                   public]
+   [cddar                   public]
+   [cdddr                   public]
+   [caaaar                  public]
+   [caaadr                  public]
+   [caadar                  public]
+   [caaddr                  public]
+   [cadaar                  public]
+   [cadadr                  public]
+   [caddar                  public]
+   [cadddr                  public]
+   [cdaaar                  public]
+   [cdaadr                  public]
+   [cdadar                  public]
+   [cdaddr                  public]
+   [cddaar                  public]
+   [cddadr                  public]
+   [cdddar                  public]
+   [cddddr                  public]
+   [set-car!                public]
+   [set-cdr!                public]
+   [list                    public]
+   [list*                   ADDME]
+   [list?                   public]
+   [list-ref                public]
+   [length                  public]
+   [make-list               public]
+   [reverse                 public]
+   [append                  public]
+   [list-ref                public]
+   [memq                    public]
+   [memv                    public]
+   [assq                    public]
+   [map                     public]
+   [for-each                public]
+   [andmap                  public]
+   [ormap                   public]
+   ;;; vectors
+   [make-vector             public]
+   [vector                  public]
+   [vector-length           public]
+   [vector-ref              public]
+   [vector-set!             public]
+   [list->vector            public]
+   [vector->list            public]
+   ;;; strings
+   [make-string             public]
+   [string                  public]
+   [string-length           public]
+   [string-ref              public]
+   [string-set!             public]
+   [list->string            public]
+   [string->list            public]
+   [string-append           public]
+   [substring               public]
+   [string=?                public]
+   [fixnum->string          public]
+   ;;; symbols
+   [gensym                  public]
+   [gensym?                 public]
+   [symbol->string          public]
+   [gensym->unique-string   public]
+   [gensym-prefix           public]
+   [gensym-count            public]
+   [print-gensym            public]
+   [string->symbol          public]
+   [top-level-value         public]
+   [top-level-bound?        public]
+   [set-top-level-value!    public]
+   [primitive-set!          public]
+   [getprop                 public]
+   [putprop                 public]
+   [remprop                 public]
+   [property-list           public]
+   [oblist                  public]
+   [uuid                    public]
+   ;;; eof
+   [eof-object              public]
+   [void                    public]
+   ;;; control/debugging
+   [print-error             public]
+   [error                   public]
+   [current-error-handler   public]
+   [exit                    public]
+   [apply                   public]
+   [make-parameter          public]
+   ;;; output
+   [output-port?            public]
+   [console-output-port     public]
+   [current-output-port     public]
+   [standard-output-port    public]
+   [standard-error-port     public]
+   [open-output-file        public]
+   [open-output-string      public]
+   [with-output-to-file     public]
+   [call-with-output-file   public]
+   [with-input-from-file    public]
+   [call-with-input-file    public]
+   [get-output-string       public]
+   [close-output-port       public]
+   [flush-output-port       public]
+   [write-char              public]
+   [output-port-name        public]
+   [newline                 public]
+   ;;; input
+   [input-port?             public]
+   [standard-input-port     public]
+   [console-input-port      public]
+   [current-input-port      public]
+   [open-input-file         public]
+   [close-input-port        public]
+   [reset-input-port!       public]
+   [read-char               public]
+   [peek-char               public]
+   [unread-char             public]
+   [input-port-name         public]
+   ;;; writing/printing
+   [write                   public]
+   [display                 public]
+   [printf                  public]
+   [fprintf                 public]
+   [format                  public]
+   [read-token              public]
+   [read                    public]
+   ;;; evaluation
+   [primitive?               public]
+   [expand                  public]
+   [syntax-error            public]
+   [current-expand          public]
+   [expand-mode             public]
+   [assembler-output        public]
+   [compile-file            public]
+   [fasl-write              public]
+
+   [$sc-put-cte   public]
+   [sc-expand   public]
+   [$make-environment   public]
+   [environment?   public]
+   [interaction-environment   public]
+   [identifier?   public]
+   [syntax->list   public]
+   [syntax-object->datum   public]
+   [datum->syntax-object   public]
+   [generate-temporaries   public]
+   [free-identifier=?   public]
+   [bound-identifier=?   public]
+   [literal-identifier=?   public]
+   [syntax-error   public]
+   [$syntax-dispatch   public]
+
+
+
+   [interpret               public]
+   [eval                    public]
+   [current-eval            public]
+   [load                    public]
+   [new-cafe                public]
+   [collect                 public]
+   [call/cc                 public]
+   [call/cf                 library]
+   [dynamic-wind            public]
+   [values                  public]
+   [call-with-values        public]
+   [make-traced-procedure   library]
+   [trace-symbol!           library]
+   [untrace-symbol!         library]
+   ;;; record
+   [$base-rtd               library]
+   [record?                 public]
+   [record-rtd              public]
+   [record-name             public]
+   [record-printer          public]
+   [record-length           public]
+   [record-ref              public]
+   [record-set!             public]
+   ;;; record rtds
+   [make-record-type        public]
+   [record-type-name        public]
+   [record-type-descriptor  public]
+   [record-type-symbol      public]
+   [record-type-field-names public]
+   [record-constructor      public]
+   [record-predicate        public]
+   [record-field-accessor   public]
+   [record-field-mutator    public]
+   ;;; hash tables
+   [make-hash-table         public]
+   [hash-table?             public]
+   [get-hash-table          public]
+   [put-hash-table!         public]
+   ;;; asm
+   [make-code               public]
+   [code?                   public]
+   [make-code-executable!   public]
+   [code-instr-size         public]
+   [code-reloc-size         public]
+   [code-closure-size       public]
+   [set-code-byte!          public]
+   [set-code-word!          public]
+   [set-code-object!        public]
+   [set-code-foreign-object!        public]
+   [set-code-object+offset! public]
+   [set-code-object+offset/rel! public]
+   [set-code-object/reloc/relative!  public]
+   [code-reloc-vec          public]
+   [code-code-vec           public]
+   [code->closure           public]
+   [list*->code*            library]
+   ;;;
+   ;;; POSIX
+   ;;;
+   [fork                    public]
+   [posix-fork              public]
+   [system                  public]
+   [$debug                      public]
+   [$underflow-misaligned-error public]
+   ))
+
+
+(define (primitive? x)
+  (cond
+    [(assq x primitives-table) #t]
+    [(assq x open-coded-primitives) #t]
+    [else #f]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [(assq x primitives-table) #f]
+    [else (error 'open-codeable "invalid primitive ~s" x)]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name assigned))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record recbind (lhs* rhs* body))
+(define-record fix (lhs* rhs* body))
+
+(define-record seq (e0 e1))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define unique-var
+  (let ([counter 0])
+    (lambda (x)
+      (let ([g (gensym (format "~a:~a" x counter))])
+        (set! counter (fxadd1 counter))
+        (make-var g #f)))))
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)])
+              (let ([nlhs* (gen-fml* lhs*)])
+                (let ([env (extend-env lhs* nlhs* env)])
+                  (make-recbind nlhs* 
+                                (map (lambda (rhs) (E rhs env)) rhs*)
+                                (E body env))))))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)]
+                  [v* (map (lambda (x) '(void)) bind*)]
+                  [t* (map (lambda (x) (gensym)) bind*)])
+              (E `((case-lambda 
+                     [,lhs* 
+                       ((case-lambda 
+                          [,t* 
+                           (begin ,@(map (lambda (x v) `(set! ,x ,v)) lhs* t*)
+                                  ,body)])
+                        ,@rhs*)])
+                   ,@v*)
+                 env)))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (if (primitive? var)
+                (make-primref var)
+                (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (cond
+              [(primitive? var) (make-primref var)]
+              [else (error 'recordize "invalid top-level var ~s" var)]))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(recbind lhs* rhs* body) 
+       `(letrec ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(fix lhs* rhs* body) 
+       `(fix ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (make-recbind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+(define (optimize-letrec x)
+  (define who 'optimize-letrec)
+  (define (extend-hash lhs* h ref)
+    (for-each (lambda (lhs) (put-hash-table! h lhs #t)) lhs*)
+    (lambda (x)
+      (unless (get-hash-table h x #f)
+        (put-hash-table! h x #t)
+        (ref x))))
+  (define (E* x* ref comp)
+    (cond
+      [(null? x*) '()]
+      [else
+       (cons (E (car x*) ref comp)
+             (E* (cdr x*) ref comp))]))  
+  (define (do-rhs* i lhs* rhs* ref comp vref vcomp)
+    (cond
+      [(null? rhs*) '()]
+      [else
+       (let ([h (make-hash-table)])
+         (let ([ref
+                (lambda (x)
+                  (unless (get-hash-table h x #f)
+                    (put-hash-table! h x #t)
+                    (ref x)
+                    (when (memq x lhs*)
+                      (vector-set! vref i #t))))]
+               [comp
+                (lambda ()
+                  (vector-set! vcomp i #t)
+                  (comp))])
+           (cons (E (car rhs*) ref comp)
+                 (do-rhs* (fxadd1 i) lhs* (cdr rhs*) ref comp vref vcomp))))]))
+  (define (partition-rhs* i lhs* rhs* vref vcomp)
+    (cond
+      [(null? lhs*) (values '() '() '() '() '() '())]
+      [else
+       (let-values 
+         ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+           (partition-rhs* (fxadd1 i) (cdr lhs*) (cdr rhs*) vref vcomp)]
+          [(lhs rhs) (values (car lhs*) (car rhs*))])
+         (cond
+           [(var-assigned lhs) 
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [(clambda? rhs)
+            (values slhs* srhs* (cons lhs llhs*) (cons rhs lrhs*) clhs* crhs*)]
+           [(or (vector-ref vref i) (vector-ref vcomp i))
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [else
+            (values (cons lhs slhs*) (cons rhs srhs*) llhs* lrhs* clhs* crhs*)]
+           ))]))
+  (define (do-recbind lhs* rhs* body ref comp)
+    (let ([h (make-hash-table)]
+          [vref (make-vector (length lhs*) #f)]
+          [vcomp (make-vector (length lhs*) #f)])
+      (let* ([ref (extend-hash lhs* h ref)]
+             [body (E body ref comp)])
+        (let ([rhs* (do-rhs* 0 lhs* rhs* ref comp vref vcomp)])
+          (let-values ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+                        (partition-rhs* 0 lhs* rhs* vref vcomp)])
+            (let ([v* (map (lambda (x) (make-primcall 'void '())) clhs*)]
+                  [t* (map (lambda (x) (unique-var 'tmp)) clhs*)])
+              (make-bind slhs* srhs*
+                (make-bind clhs* v*
+                  (make-fix llhs* lrhs*
+                    (make-bind t* crhs*
+                      (build-assign* clhs* t* body)))))))))))
+  (define (build-assign* lhs* rhs* body)
+    (cond
+      [(null? lhs*)  body]
+      [else
+       (make-seq
+         (make-assign (car lhs*) (car rhs*))
+         (build-assign* (cdr lhs*) (cdr rhs*) body))]))
+  (define (E x ref comp)
+    (record-case x
+      [(constant) x]
+      [(var) (ref x) x]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (ref lhs)
+       (make-assign lhs (E rhs ref comp))]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let ([rhs* (E* rhs* ref comp)])
+         (let ([h (make-hash-table)])
+           (let ([body (E body (extend-hash lhs* h ref) comp)])
+             (make-bind lhs* rhs* body))))]
+      [(recbind lhs* rhs* body)
+       (if (null? lhs*)
+           (E body ref comp)
+           (do-recbind lhs* rhs* body ref comp))]
+      [(conditional e0 e1 e2)
+       (make-conditional (E e0 ref comp) (E e1 ref comp) (E e2 ref comp))]
+      [(seq e0 e1) (make-seq (E e0 ref comp) (E e1 ref comp))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (let ([h (make-hash-table)])
+                     (let ([body (E body (extend-hash fml* h ref) void)])
+                       (make-clambda-case fml* proper body)))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (when (memq rator '(call/cc call/cf))
+         (comp))
+       (make-primcall rator (E* rand* ref comp))]
+      [(funcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-funcall rator rand*))]
+      [(appcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-appcall rator rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (E* rand* ref comp))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x (lambda (x) (error who "free var ~s found" x))
+       void))
+
+
+(define (remove-letrec x)
+  (define who 'remove-letrec)
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (let ([t* (map (lambda (lhs) (unique-var 'tmp)) lhs*)]
+             [v* (map (lambda (lhs) (make-primcall 'void '())) lhs*)])
+         (make-bind lhs* v*
+           (make-bind t* (map Expr rhs*)
+             (let f ([lhs* lhs*] [t* t*])
+               (cond
+                 [(null? lhs*) (Expr body)]
+                 [else
+                  (make-seq
+                    (make-assign (car lhs*) (car t*))
+                    (f (cdr lhs*) (cdr t*)))])))))]
+      ;[(fix lhs* rhs* body)
+      ; (Expr (make-recbind lhs* rhs* body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (for-each Expr x*))
+  (define (Expr x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(recbind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(fix lhs* rhs* body)
+       (Expr* rhs*) 
+       (Expr body)
+       (when (ormap var-assigned lhs*)
+         (error 'uncover-assigned "a fix lhs is assigned"))]
+      [(conditional test conseq altern)
+       (begin (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (begin (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (for-each
+         (lambda (cls)
+           (Expr (clambda-case-body cls)))
+         cls*)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (Expr rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (rewrite-assignments x)
+  (define who 'rewrite-assignments)
+  (define (fix-lhs* lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* (cdr lhs*))])
+           (cond
+             [(var-assigned x)
+              (let ([t (unique-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(var-assigned x) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix-lhs* fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (var-assigned lhs)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+    (uncover-assigned x)
+    (rewrite-assignments x))
+  
+
+
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+   (define (do-clambda* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (do-clambda (car x*))]
+                    [(d d-free) (do-clambda* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (do-clambda x)
+    (record-case x 
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(fix lhs* rhs* body)
+       (let-values ([(rhs* rfree) (do-clambda* rhs*)]
+                    [(body bfree) (Expr body)])
+          (values (make-fix lhs* rhs* body)
+                  (difference (union bfree rfree) lhs*)))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(clambda)
+       (do-clambda ex)]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? code? $forward-ptr? bwp-object?
+        pointer-value)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-instr-size $code-reloc-size $code-closure-size
+        $set-code-byte! $set-code-word! 
+        $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+        $make-record $record? $record/rtd? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (simplify* arg* '() '()
+         (lambda (arg* lhs* rhs*)
+           (make-bind^ lhs* rhs* 
+             (make-primcall op arg*))))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body) (Expr body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body) (Tail body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list (make-constant n)))
+        (make-primcall 'void '()))
+      body))
+  (define (closure-size x)
+    (record-case x 
+      [(closure code free*)
+       (align (fx+ disp-closure-data (fx* (length free*) wordsize)))]
+      [else (error 'closure-size "~s is not a closure" x)]))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) 
+       (check-const (closure-size x) x)]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Expr body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Expr body))))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(vector)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Tail body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Tail body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp #t (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" call-convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (do-closure r)
+    (lambda (x)
+      (record-case x
+        [(closure code free*)
+         (make-closure code (simple* free* r))])))
+  (define (do-fix lhs* rhs* body si r live k)
+    (let f ([l* lhs*] [nlhs* '()] [si si] [r r] [live live])
+      (cond
+        [(null? l*) 
+         (make-fix (reverse nlhs*) 
+                   (map (do-closure r) rhs*)
+                   (k body si r live))]
+        [else
+         (let ([v (make-frame-var si)])
+           (f (cdr l*) (cons v nlhs*) (fxadd1 si) 
+              (cons (cons (car l*) v) r)
+              (cons si live)))])))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (case op
+;         [(values) (make-primcall op (simple* arg* r))]
+         [else (make-return (make-primcall op (simple* arg* r)))])]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'tail live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+         
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag #x2F)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-closuresize   12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+
+  (define record-ptag  5)
+  (define record-pmask 7)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define dirty-word -1))
+
+(define (align n)
+  (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [($record/rtd?)
+      (cond
+        [Lf
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int vector-mask) eax)
+                (cmpl (int vector-tag) eax)
+                (jne Lf)
+                (movl (Simple (cadr rand*)) eax)
+                (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                (jne Lf)
+                (if Lt
+                    (cons (jmp Lt) ac)
+                    ac))]
+        [Lt
+         (let ([Ljoin (unique-label)])
+           (list* (movl (Simple (car rand*)) eax)
+                  (movl eax ebx)
+                  (andl (int vector-mask) eax)
+                  (cmpl (int vector-tag) eax)
+                  (jne Ljoin)
+                  (movl (Simple (cadr rand*)) eax)
+                  (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                  (je Lt)
+                  (label Ljoin)
+                  ac))]
+        [else ac])]
+     [(code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx< i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-instr-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag) 
+         (cons (sall (int fx-shift) eax) ac))]
+     [($code-reloc-size) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-closure-size) 
+       (indirect-ref arg* (fx- disp-code-closuresize vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $set-code-byte! $set-code-word!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? code? 
+       $record? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (closure-size x)
+    (align (fx+ disp-closure-data
+                (fx* wordsize (length (closure-free* x))))))
+  (define (assign-codes rhs* n* i ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (record-case (car rhs*)
+         [(closure label free*)
+          (cons (movl (Simple label) (mem i apr))
+                (assign-codes 
+                  (cdr rhs*) (cdr n*) (fx+ i (car n*)) ac))])]))
+  (define (whack-free x i n* rhs* ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let ([free (closure-free* (car rhs*))])
+         (let f ([free free] [j (fx+ i disp-closure-data)])
+           (cond
+             [(null? free) 
+              (whack-free x (fx+ i (car n*)) (cdr n*) (cdr rhs*) ac)]
+             [(eq? (car free) x)
+              (cons
+                (movl eax (mem j apr))
+                (f (cdr free) (fx+ j wordsize)))]
+             [else (f (cdr free) (fx+ j wordsize))])))]))
+  (define (assign-nonrec-free* rhs* all-rhs* n* seen ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let f ([ls (closure-free* (car rhs*))] [seen seen])
+         (cond
+           [(null? ls) 
+            (assign-nonrec-free* (cdr rhs*) all-rhs* n* seen ac)]
+           [(memq (car ls) seen) (f (cdr ls) seen)]
+           [else
+            (cons
+              (movl (Simple (car ls)) eax)
+              (whack-free (car ls) 0 n* all-rhs*
+                (f (cdr ls) (cons (car ls) seen))))]))]))
+  (define (assign-rec-free* lhs* rhs* all-n* ac)
+    (list* (movl apr eax)
+           (addl (int closure-tag) eax)
+           (let f ([lhs* lhs*] [n* all-n*])
+             (cond
+               [(null? (cdr lhs*)) 
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs* ac))]
+               [else
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs*
+                    (cons
+                      (addl (int (car n*)) eax)
+                      (f (cdr lhs*) (cdr n*)))))]))))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (do-fix lhs* rhs* ac)
+    ;;; 1. first, set the code pointers in the right places
+    ;;; 2. next, for every variable appearing in the rhs* but is not in
+    ;;;    the lhs*, load it once and set it everywhere it occurs.
+    ;;; 3. next, compute the values of the lhs*, and for every computed
+    ;;;    value, store it on the stack, and set it everywhere it occurs
+    ;;;    in the rhs*
+    ;;; 4. that's it.
+    (let* ([n* (map closure-size rhs*)])
+      (assign-codes rhs* n* 0
+        (assign-nonrec-free* rhs* rhs* n* lhs*
+          (assign-rec-free* lhs* rhs* n*
+            (cons (addl (int (sum 0 n*)) apr) ac))))))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* (NonTail body ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else
+            (error who "invalid convention ~s for call-cp" call-convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Pred body Lt Lf ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let ([Lf (unique-label)] [Ljoin (unique-label)])
+        (Pred test #f Lf
+          (Effect conseq
+            (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Effect body ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (NonTail val
+           (cons (movl eax (idx->frame-loc i)) ac))]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (NonTail body
+        (cond
+          [check
+           (list* 
+             (movl eax cpr) 
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac)]
+          [else
+           (list* 
+             (movl eax cpr) 
+             ac)]))]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Tail body ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(call-cp call-convention rp-convention idx argc mask)
+      (unless (eq? rp-convention 'tail)
+        (error who "nontail rp (~s) in tail context" rp-convention))
+      (let f ([i 0])
+        (cond
+          [(fx= i argc)
+           (case call-convention
+             [(normal) 
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (tail-indirect-cpr-call)
+                ac)]
+             [(apply)
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (jmp (label SL_apply)) 
+                ac)]
+             [else
+              (error who "invalid conv ~s in tail call-cpr" call-convention)])]
+          [else
+            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+                                   (fx- 0 wordsize)) fpr)
+                         eax)
+                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (fx+ disp-closure-data (fx* wordsize (length free)))
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(module ()
+(list*->code*
+  (list
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list disp-closure-data
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list disp-closure-data
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list 
+          (fx+ disp-closure-data wordsize)
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    )))
+
+
+
+(define (compile-expr expr)
+  (let* ([p (recordize expr)]
+         [p (optimize-direct-calls p)]
+         [p (optimize-letrec p)]
+         [p (remove-letrec p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (car code*)))
+
+(define compile-file
+  (lambda (input-file output-file . rest)
+    (let ([ip (open-input-file input-file)]
+          [op (apply open-output-file output-file rest)])
+      (let f ()
+        (let ([x (read ip)])
+          (unless (eof-object? x)
+            (fasl-write (compile-expr (expand x)) op)
+            (f))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+(primitive-set! 'compile-file compile-file)
+(primitive-set! 'assembler-output (make-parameter #f))
+)
+
diff --git a/src/libcompile-6.6.ss b/src/libcompile-6.6.ss
new file mode 100644
index 0000000..6e2ba57
--- /dev/null
+++ b/src/libcompile-6.6.ss
@@ -0,0 +1,3446 @@
+
+
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(let ()
+
+(define-syntax cond-expand
+  (lambda (x)
+    (syntax-case x ()
+      [(_ test conseq altern)
+       (if (eval (syntax-object->datum #'test))
+           #'conseq
+           #'altern)])))
+
+(cond-expand (eq? "" "")
+  (include "record-case.chez.ss")
+  (include "record-case.ss"))
+
+
+(include "set-operations.ss")
+
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record/rtd?       2    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    ;;;
+    ;;; asm
+    ;;;
+    [$code?              1    pred]
+    [$code-size          1    value]
+    [$code-reloc-vector  1    value]
+    [$code-closure-size  1    value]
+    [$code-ref           2    value]
+    [$code-set!          3    value]
+    [$code->closure      1    value]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+
+;;; primitives table section
+(define primitives-table
+ '(;;; system locations used by the C/Scheme interface
+   [$apply-nonprocedure-error-handler library]
+   [$incorrect-args-error-handler     library]
+   [$multiple-values-error            library]
+   [$intern                           library]
+   [do-overflow                       library]
+   [do-vararg-overflow                library]
+   [do-stack-overflow                 library]
+   ;;; type predicates
+   [fixnum?                 public]
+   [immediate?              public]
+   [boolean?                public]
+   [char?                   public]
+   [null?                   public]
+   [pair?                   public]
+   [symbol?                 public]
+   [vector?                 public]
+   [string?                 public]
+   [procedure?              public]
+   [eof-object?             public]
+   [not                     public]
+   [eq?                     public]
+   [equal?                  public]
+   ;;; fixnum primitives
+   [fxadd1                  public]
+   [fxsub1                  public]
+   [fx+                     public]
+   [fx-                     public]
+   [fx*                     public]
+   [fxsll                   public]
+   [fxsra                   public]
+   [fxlogor                 public]
+   [fxlogand                public]
+   [fxlogxor                public]
+   [fxlognot                public]
+   [fxquotient              public]
+   [fxremainder             public]
+   [fxmodulo                public]
+   ;;; fixnum predicates
+   [fxzero?                 public]
+   [fx=                     public]
+   [fx<                     public]
+   [fx<=                    public]
+   [fx>                     public]
+   [fx>=                    public]
+   ;;; characters
+   [char=?                  public]
+   [char<?                  public]
+   [char<=?                 public]
+   [char>?                  public]
+   [char>=?                 public]
+   [integer->char           public]
+   [char->integer           public]
+   ;;; lists
+   [cons                    public]
+   [car                     public]
+   [cdr                     public]
+   [caar                    public]
+   [cadr                    public]
+   [cdar                    public]
+   [cddr                    public]
+   [caaar                   public]
+   [caadr                   public]
+   [cadar                   public]
+   [caddr                   public]
+   [cdaar                   public]
+   [cdadr                   public]
+   [cddar                   public]
+   [cdddr                   public]
+   [caaaar                  public]
+   [caaadr                  public]
+   [caadar                  public]
+   [caaddr                  public]
+   [cadaar                  public]
+   [cadadr                  public]
+   [caddar                  public]
+   [cadddr                  public]
+   [cdaaar                  public]
+   [cdaadr                  public]
+   [cdadar                  public]
+   [cdaddr                  public]
+   [cddaar                  public]
+   [cddadr                  public]
+   [cdddar                  public]
+   [cddddr                  public]
+   [set-car!                public]
+   [set-cdr!                public]
+   [list                    public]
+   [list*                   ADDME]
+   [list?                   public]
+   [list-ref                public]
+   [length                  public]
+   [make-list               public]
+   [reverse                 public]
+   [append                  public]
+   [list-ref                public]
+   [memq                    public]
+   [memv                    public]
+   [assq                    public]
+   [map                     public]
+   [for-each                public]
+   [andmap                  public]
+   [ormap                   public]
+   ;;; vectors
+   [make-vector             public]
+   [vector                  public]
+   [vector-length           public]
+   [vector-ref              public]
+   [vector-set!             public]
+   [list->vector            public]
+   [vector->list            public]
+   ;;; strings
+   [make-string             public]
+   [string                  public]
+   [string-length           public]
+   [string-ref              public]
+   [string-set!             public]
+   [list->string            public]
+   [string->list            public]
+   [string-append           public]
+   [substring               public]
+   [string=?                public]
+   [fixnum->string          public]
+   ;;; symbols
+   [gensym                  public]
+   [gensym?                 public]
+   [symbol->string          public]
+   [gensym->unique-string   public]
+   [gensym-prefix           public]
+   [gensym-count            public]
+   [print-gensym            public]
+   [string->symbol          public]
+   [top-level-value         public]
+   [top-level-bound?        public]
+   [set-top-level-value!    public]
+   [primitive-set!          public]
+   [getprop                 public]
+   [putprop                 public]
+   [remprop                 public]
+   [property-list           public]
+   [oblist                  public]
+   [uuid                    public]
+   ;;; eof
+   [eof-object              public]
+   [void                    public]
+   ;;; control/debugging
+   [print-error             public]
+   [error                   public]
+   [current-error-handler   public]
+   [exit                    public]
+   [apply                   public]
+   [make-parameter          public]
+   ;;; output
+   [output-port?            public]
+   [console-output-port     public]
+   [current-output-port     public]
+   [standard-output-port    public]
+   [standard-error-port     public]
+   [open-output-file        public]
+   [open-output-string      public]
+   [with-output-to-file     public]
+   [call-with-output-file   public]
+   [with-input-from-file    public]
+   [call-with-input-file    public]
+   [get-output-string       public]
+   [close-output-port       public]
+   [flush-output-port       public]
+   [write-char              public]
+   [output-port-name        public]
+   [newline                 public]
+   ;;; input
+   [input-port?             public]
+   [standard-input-port     public]
+   [console-input-port      public]
+   [current-input-port      public]
+   [open-input-file         public]
+   [close-input-port        public]
+   [reset-input-port!       public]
+   [read-char               public]
+   [peek-char               public]
+   [unread-char             public]
+   [input-port-name         public]
+   ;;; writing/printing
+   [write                   public]
+   [display                 public]
+   [printf                  public]
+   [fprintf                 public]
+   [format                  public]
+   [read-token              public]
+   [read                    public]
+   ;;; evaluation
+   [primitive?               public]
+   [expand                  public]
+   [syntax-error            public]
+   [current-expand          public]
+   [expand-mode             public]
+   [assembler-output        public]
+   [compile-file            public]
+   [fasl-write              public]
+
+   [$sc-put-cte   public]
+   [sc-expand   public]
+   [$make-environment   public]
+   [environment?   public]
+   [interaction-environment   public]
+   [identifier?   public]
+   [syntax->list   public]
+   [syntax-object->datum   public]
+   [datum->syntax-object   public]
+   [generate-temporaries   public]
+   [free-identifier=?   public]
+   [bound-identifier=?   public]
+   [literal-identifier=?   public]
+   [syntax-error   public]
+   [$syntax-dispatch   public]
+
+
+
+   [interpret               public]
+   [compile                 public]
+   [eval                    public]
+   [current-eval            public]
+   [load                    public]
+   [new-cafe                public]
+   [collect                 public]
+   [call/cc                 public]
+   [call/cf                 library]
+   [dynamic-wind            public]
+   [values                  public]
+   [call-with-values        public]
+   [make-traced-procedure   library]
+   [trace-symbol!           library]
+   [untrace-symbol!         library]
+   ;;; record
+   [$base-rtd               library]
+   [record?                 public]
+   [record-rtd              public]
+   [record-name             public]
+   [record-printer          public]
+   [record-length           public]
+   [record-ref              public]
+   [record-set!             public]
+   ;;; record rtds
+   [make-record-type        public]
+   [record-type-name        public]
+   [record-type-descriptor  public]
+   [record-type-symbol      public]
+   [record-type-field-names public]
+   [record-constructor      public]
+   [record-predicate        public]
+   [record-field-accessor   public]
+   [record-field-mutator    public]
+   ;;; hash tables
+   [make-hash-table         public]
+   [hash-table?             public]
+   [get-hash-table          public]
+   [put-hash-table!         public]
+   ;;; asm
+   [make-code               public]
+   [code?                   public]
+   [code-size               public]
+   [code-closure-size       public]
+   [code-ref                public]
+   [code-set!               public]
+   [code-reloc-vector       public]
+   [set-code-reloc-vector!  public]
+   [code->closure           public]
+   [list*->code*            library]
+   ;;;
+   ;;; POSIX
+   ;;;
+   [fork                    public]
+   [posix-fork              public]
+   [system                  public]
+   [$debug                      public]
+   [$underflow-misaligned-error public]
+   ))
+
+
+(define (primitive? x)
+  (cond
+    [(assq x primitives-table) #t]
+    [(assq x open-coded-primitives) #t]
+    [else #f]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [(assq x primitives-table) #f]
+    [else (error 'open-codeable "invalid primitive ~s" x)]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name assigned))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record recbind (lhs* rhs* body))
+(define-record fix (lhs* rhs* body))
+
+(define-record seq (e0 e1))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define unique-var
+  (let ([counter 0])
+    (lambda (x)
+      (let ([g (gensym (format "~a:~a" x counter))])
+        (set! counter (fxadd1 counter))
+        (make-var g #f)))))
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)])
+              (let ([nlhs* (gen-fml* lhs*)])
+                (let ([env (extend-env lhs* nlhs* env)])
+                  (make-recbind nlhs* 
+                                (map (lambda (rhs) (E rhs env)) rhs*)
+                                (E body env))))))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)]
+                  [v* (map (lambda (x) '(void)) bind*)]
+                  [t* (map (lambda (x) (gensym)) bind*)])
+              (E `((case-lambda 
+                     [,lhs* 
+                       ((case-lambda 
+                          [,t* 
+                           (begin ,@(map (lambda (x v) `(set! ,x ,v)) lhs* t*)
+                                  ,body)])
+                        ,@rhs*)])
+                   ,@v*)
+                 env)))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (if (primitive? var)
+                (make-primref var)
+                (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (cond
+              [(primitive? var) (make-primref var)]
+              [else (error 'recordize "invalid top-level var ~s" var)]))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(recbind lhs* rhs* body) 
+       `(letrec ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(fix lhs* rhs* body) 
+       `(fix ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (make-recbind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+(define (optimize-letrec x)
+  (define who 'optimize-letrec)
+  (define (extend-hash lhs* h ref)
+    (for-each (lambda (lhs) (put-hash-table! h lhs #t)) lhs*)
+    (lambda (x)
+      (unless (get-hash-table h x #f)
+        (put-hash-table! h x #t)
+        (ref x))))
+  (define (E* x* ref comp)
+    (cond
+      [(null? x*) '()]
+      [else
+       (cons (E (car x*) ref comp)
+             (E* (cdr x*) ref comp))]))  
+  (define (do-rhs* i lhs* rhs* ref comp vref vcomp)
+    (cond
+      [(null? rhs*) '()]
+      [else
+       (let ([h (make-hash-table)])
+         (let ([ref
+                (lambda (x)
+                  (unless (get-hash-table h x #f)
+                    (put-hash-table! h x #t)
+                    (ref x)
+                    (when (memq x lhs*)
+                      (vector-set! vref i #t))))]
+               [comp
+                (lambda ()
+                  (vector-set! vcomp i #t)
+                  (comp))])
+           (cons (E (car rhs*) ref comp)
+                 (do-rhs* (fxadd1 i) lhs* (cdr rhs*) ref comp vref vcomp))))]))
+  (define (partition-rhs* i lhs* rhs* vref vcomp)
+    (cond
+      [(null? lhs*) (values '() '() '() '() '() '())]
+      [else
+       (let-values 
+         ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+           (partition-rhs* (fxadd1 i) (cdr lhs*) (cdr rhs*) vref vcomp)]
+          [(lhs rhs) (values (car lhs*) (car rhs*))])
+         (cond
+           [(var-assigned lhs) 
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [(clambda? rhs)
+            (values slhs* srhs* (cons lhs llhs*) (cons rhs lrhs*) clhs* crhs*)]
+           [(or (vector-ref vref i) (vector-ref vcomp i))
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [else
+            (values (cons lhs slhs*) (cons rhs srhs*) llhs* lrhs* clhs* crhs*)]
+           ))]))
+  (define (do-recbind lhs* rhs* body ref comp)
+    (let ([h (make-hash-table)]
+          [vref (make-vector (length lhs*) #f)]
+          [vcomp (make-vector (length lhs*) #f)])
+      (let* ([ref (extend-hash lhs* h ref)]
+             [body (E body ref comp)])
+        (let ([rhs* (do-rhs* 0 lhs* rhs* ref comp vref vcomp)])
+          (let-values ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+                        (partition-rhs* 0 lhs* rhs* vref vcomp)])
+            (let ([v* (map (lambda (x) (make-primcall 'void '())) clhs*)]
+                  [t* (map (lambda (x) (unique-var 'tmp)) clhs*)])
+              (make-bind slhs* srhs*
+                (make-bind clhs* v*
+                  (make-fix llhs* lrhs*
+                    (make-bind t* crhs*
+                      (build-assign* clhs* t* body)))))))))))
+  (define (build-assign* lhs* rhs* body)
+    (cond
+      [(null? lhs*)  body]
+      [else
+       (make-seq
+         (make-assign (car lhs*) (car rhs*))
+         (build-assign* (cdr lhs*) (cdr rhs*) body))]))
+  (define (E x ref comp)
+    (record-case x
+      [(constant) x]
+      [(var) (ref x) x]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (ref lhs)
+       (make-assign lhs (E rhs ref comp))]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let ([rhs* (E* rhs* ref comp)])
+         (let ([h (make-hash-table)])
+           (let ([body (E body (extend-hash lhs* h ref) comp)])
+             (make-bind lhs* rhs* body))))]
+      [(recbind lhs* rhs* body)
+       (if (null? lhs*)
+           (E body ref comp)
+           (do-recbind lhs* rhs* body ref comp))]
+      [(conditional e0 e1 e2)
+       (make-conditional (E e0 ref comp) (E e1 ref comp) (E e2 ref comp))]
+      [(seq e0 e1) (make-seq (E e0 ref comp) (E e1 ref comp))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (let ([h (make-hash-table)])
+                     (let ([body (E body (extend-hash fml* h ref) void)])
+                       (make-clambda-case fml* proper body)))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (when (memq rator '(call/cc call/cf))
+         (comp))
+       (make-primcall rator (E* rand* ref comp))]
+      [(funcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-funcall rator rand*))]
+      [(appcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-appcall rator rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (E* rand* ref comp))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x (lambda (x) (error who "free var ~s found" x))
+       void))
+
+
+(define (remove-letrec x)
+  (define who 'remove-letrec)
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (let ([t* (map (lambda (lhs) (unique-var 'tmp)) lhs*)]
+             [v* (map (lambda (lhs) (make-primcall 'void '())) lhs*)])
+         (make-bind lhs* v*
+           (make-bind t* (map Expr rhs*)
+             (let f ([lhs* lhs*] [t* t*])
+               (cond
+                 [(null? lhs*) (Expr body)]
+                 [else
+                  (make-seq
+                    (make-assign (car lhs*) (car t*))
+                    (f (cdr lhs*) (cdr t*)))])))))]
+      ;[(fix lhs* rhs* body)
+      ; (Expr (make-recbind lhs* rhs* body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (for-each Expr x*))
+  (define (Expr x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(recbind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(fix lhs* rhs* body)
+       (Expr* rhs*) 
+       (Expr body)
+       (when (ormap var-assigned lhs*)
+         (error 'uncover-assigned "a fix lhs is assigned"))]
+      [(conditional test conseq altern)
+       (begin (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (begin (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (for-each
+         (lambda (cls)
+           (Expr (clambda-case-body cls)))
+         cls*)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (Expr rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (rewrite-assignments x)
+  (define who 'rewrite-assignments)
+  (define (fix-lhs* lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* (cdr lhs*))])
+           (cond
+             [(var-assigned x)
+              (let ([t (unique-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(var-assigned x) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix-lhs* fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (var-assigned lhs)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+    (uncover-assigned x)
+    (rewrite-assignments x))
+  
+
+
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+   (define (do-clambda* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (do-clambda (car x*))]
+                    [(d d-free) (do-clambda* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (do-clambda x)
+    (record-case x 
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(fix lhs* rhs* body)
+       (let-values ([(rhs* rfree) (do-clambda* rhs*)]
+                    [(body bfree) (Expr body)])
+          (values (make-fix lhs* rhs* body)
+                  (difference (union bfree rfree) lhs*)))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(clambda)
+       (do-clambda ex)]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? $code? $forward-ptr? bwp-object?
+        pointer-value)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-size $code-reloc-vector $code-closure-size 
+        $code-ref $code-set!
+        $make-record $record? $record/rtd? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (simplify* arg* '() '()
+         (lambda (arg* lhs* rhs*)
+           (make-bind^ lhs* rhs* 
+             (make-primcall op arg*))))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body) (Expr body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body) (Tail body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-funcall (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant n) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-funcall (make-primref 'do-overflow) 
+                      (list (make-constant n)))
+        (make-primcall 'void '()))
+      body))
+  (define (closure-size x)
+    (record-case x 
+      [(closure code free*)
+       (align (fx+ disp-closure-data (fx* (length free*) wordsize)))]
+      [else (error 'closure-size "~s is not a closure" x)]))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) 
+       (check-const (closure-size x) x)]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Expr body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Expr body))))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(vector)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Tail body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Tail body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp #t (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" call-convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (do-closure r)
+    (lambda (x)
+      (record-case x
+        [(closure code free*)
+         (make-closure code (simple* free* r))])))
+  (define (do-fix lhs* rhs* body si r live k)
+    (let f ([l* lhs*] [nlhs* '()] [si si] [r r] [live live])
+      (cond
+        [(null? l*) 
+         (make-fix (reverse nlhs*) 
+                   (map (do-closure r) rhs*)
+                   (k body si r live))]
+        [else
+         (let ([v (make-frame-var si)])
+           (f (cdr l*) (cons v nlhs*) (fxadd1 si) 
+              (cons (cons (car l*) v) r)
+              (cons si live)))])))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (case op
+;         [(values) (make-primcall op (simple* arg* r))]
+         [else (make-return (make-primcall op (simple* arg* r)))])]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'tail live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op (simple* arg* r))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+         
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag #x2F)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-closuresize   12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+
+  (define record-ptag  5)
+  (define record-pmask 7)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define dirty-word -1))
+
+(define (align n)
+  (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [($record/rtd?)
+      (cond
+        [Lf
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int vector-mask) eax)
+                (cmpl (int vector-tag) eax)
+                (jne Lf)
+                (movl (Simple (cadr rand*)) eax)
+                (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                (jne Lf)
+                (if Lt
+                    (cons (jmp Lt) ac)
+                    ac))]
+        [Lt
+         (let ([Ljoin (unique-label)])
+           (list* (movl (Simple (car rand*)) eax)
+                  (movl eax ebx)
+                  (andl (int vector-mask) eax)
+                  (cmpl (int vector-tag) eax)
+                  (jne Ljoin)
+                  (movl (Simple (cadr rand*)) eax)
+                  (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                  (je Lt)
+                  (label Ljoin)
+                  ac))]
+        [else ac])]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx< i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($code-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int 0) eax)
+              (movb (mem (fx- disp-code-data vector-tag) ebx) ah)
+              (sarl (int (fx- 8 fx-shift)) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag)  ac)]
+     [($code-reloc-vector) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-closure-size) 
+       (indirect-ref arg* (fx- disp-code-closuresize vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $code-set!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? $code? 
+       $record? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($code-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (sall (int (fx- 8 fx-shift)) ebx)
+              (movb bh (mem (fx- disp-code-data vector-tag) eax))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (closure-size x)
+    (align (fx+ disp-closure-data
+                (fx* wordsize (length (closure-free* x))))))
+  (define (assign-codes rhs* n* i ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (record-case (car rhs*)
+         [(closure label free*)
+          (cons (movl (Simple label) (mem i apr))
+                (assign-codes 
+                  (cdr rhs*) (cdr n*) (fx+ i (car n*)) ac))])]))
+  (define (whack-free x i n* rhs* ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let ([free (closure-free* (car rhs*))])
+         (let f ([free free] [j (fx+ i disp-closure-data)])
+           (cond
+             [(null? free) 
+              (whack-free x (fx+ i (car n*)) (cdr n*) (cdr rhs*) ac)]
+             [(eq? (car free) x)
+              (cons
+                (movl eax (mem j apr))
+                (f (cdr free) (fx+ j wordsize)))]
+             [else (f (cdr free) (fx+ j wordsize))])))]))
+  (define (assign-nonrec-free* rhs* all-rhs* n* seen ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let f ([ls (closure-free* (car rhs*))] [seen seen])
+         (cond
+           [(null? ls) 
+            (assign-nonrec-free* (cdr rhs*) all-rhs* n* seen ac)]
+           [(memq (car ls) seen) (f (cdr ls) seen)]
+           [else
+            (cons
+              (movl (Simple (car ls)) eax)
+              (whack-free (car ls) 0 n* all-rhs*
+                (f (cdr ls) (cons (car ls) seen))))]))]))
+  (define (assign-rec-free* lhs* rhs* all-n* ac)
+    (list* (movl apr eax)
+           (addl (int closure-tag) eax)
+           (let f ([lhs* lhs*] [n* all-n*])
+             (cond
+               [(null? (cdr lhs*)) 
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs* ac))]
+               [else
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs*
+                    (cons
+                      (addl (int (car n*)) eax)
+                      (f (cdr lhs*) (cdr n*)))))]))))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (do-fix lhs* rhs* ac)
+    ;;; 1. first, set the code pointers in the right places
+    ;;; 2. next, for every variable appearing in the rhs* but is not in
+    ;;;    the lhs*, load it once and set it everywhere it occurs.
+    ;;; 3. next, compute the values of the lhs*, and for every computed
+    ;;;    value, store it on the stack, and set it everywhere it occurs
+    ;;;    in the rhs*
+    ;;; 4. that's it.
+    (let* ([n* (map closure-size rhs*)])
+      (assign-codes rhs* n* 0
+        (assign-nonrec-free* rhs* rhs* n* lhs*
+          (assign-rec-free* lhs* rhs* n*
+            (cons (addl (int (sum 0 n*)) apr) ac))))))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* (NonTail body ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else
+            (error who "invalid convention ~s for call-cp" call-convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Pred body Lt Lf ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let ([Lf (unique-label)] [Ljoin (unique-label)])
+        (Pred test #f Lf
+          (Effect conseq
+            (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Effect body ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (NonTail val
+           (cons (movl eax (idx->frame-loc i)) ac))]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (NonTail body
+        (cond
+          [check
+           (list* 
+             (movl eax cpr) 
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac)]
+          [else
+           (list* 
+             (movl eax cpr) 
+             ac)]))]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Tail body ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(call-cp call-convention rp-convention idx argc mask)
+      (unless (eq? rp-convention 'tail)
+        (error who "nontail rp (~s) in tail context" rp-convention))
+      (let f ([i 0])
+        (cond
+          [(fx= i argc)
+           (case call-convention
+             [(normal) 
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (tail-indirect-cpr-call)
+                ac)]
+             [(apply)
+              (list* 
+                (movl (int (argc-convention argc)) eax)
+                (jmp (label SL_apply)) 
+                ac)]
+             [else
+              (error who "invalid conv ~s in tail call-cpr" call-convention)])]
+          [else
+            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+                                   (fx- 0 wordsize)) fpr)
+                         eax)
+                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (fx+ disp-closure-data (fx* wordsize (length free)))
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(module ()
+(list*->code*
+  (list
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list disp-closure-data
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list disp-closure-data
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list 
+          (fx+ disp-closure-data wordsize)
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    )))
+
+
+
+(define (compile-expr expr)
+  (let* ([p (recordize expr)]
+         [p (optimize-direct-calls p)]
+         [p (optimize-letrec p)]
+         ;[p (remove-letrec p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (car code*)))
+
+(define compile-file
+  (lambda (input-file output-file . rest)
+    (let ([ip (open-input-file input-file)]
+          [op (apply open-output-file output-file rest)])
+      (let f ()
+        (let ([x (read ip)])
+          (unless (eof-object? x)
+            (fasl-write (compile-expr (expand x)) op)
+            (f))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+(primitive-set! 'compile-file compile-file)
+(primitive-set! 'assembler-output (make-parameter #f))
+(primitive-set! 'compile
+  (lambda (x)
+    (let ([code (compile-expr (expand x))])
+      (let ([proc ($code->closure code)])
+        (proc)))))
+
+)
+
diff --git a/src/libcompile-6.7.ss b/src/libcompile-6.7.ss
new file mode 100644
index 0000000..8e21502
--- /dev/null
+++ b/src/libcompile-6.7.ss
@@ -0,0 +1,3660 @@
+
+;;; 6.7: * open-coded top-level-value, car, cdr
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(let ()
+
+(define-syntax cond-expand
+  (lambda (x)
+    (syntax-case x ()
+      [(_ test conseq altern)
+       (if (eval (syntax-object->datum #'test))
+           #'conseq
+           #'altern)])))
+
+(cond-expand (eq? "" "")
+  (include "record-case.chez.ss")
+  (include "record-case.ss"))
+
+
+(include "set-operations.ss")
+
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [list*         positive value]
+    [list             any   value]
+    [car                1   value]
+    [cdr                1   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    [$vector-memq       2   value]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    [top-level-value      1   value]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record/rtd?       2    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    [$record          any   value]
+    ;;;
+    ;;; asm
+    ;;;
+    [$code?              1    pred]
+    [$code-size          1    value]
+    [$code-reloc-vector  1    value]
+    [$code-freevars      1    value]
+    [$code-ref           2    value]
+    [$code-set!          3    value]
+    [$code->closure      1    value]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [else  #f]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name assigned))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record tailcall-cp (convention arg-count))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record recbind (lhs* rhs* body))
+(define-record fix (lhs* rhs* body))
+
+(define-record seq (e0 e1))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define (unique-var x)
+  (make-var (gensym (symbol->string x)) #f))
+
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)])
+              (let ([nlhs* (gen-fml* lhs*)])
+                (let ([env (extend-env lhs* nlhs* env)])
+                  (make-recbind nlhs* 
+                                (map (lambda (rhs) (E rhs env)) rhs*)
+                                (E body env))))))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)]
+                  [v* (map (lambda (x) '(void)) bind*)]
+                  [t* (map (lambda (x) (gensym)) bind*)])
+              (E `((case-lambda 
+                     [,lhs* 
+                       ((case-lambda 
+                          [,t* 
+                           (begin ,@(map (lambda (x v) `(set! ,x ,v)) lhs* t*)
+                                  ,body)])
+                        ,@rhs*)])
+                   ,@v*)
+                 env)))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (make-primref var))]
+         ;;; [(|#primitive|)
+         ;;;  (let ([var (cadr x)])
+         ;;;    (if (primitive? var)
+         ;;;        (make-primref var)
+         ;;;        (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (if (eq? (expand-mode) 'bootstrap)
+                (error 'compile "reference to ~s in bootstrap mode" var)
+                (make-funcall
+                  (make-primref 'top-level-value)
+                  (list (make-constant var)))))]
+         ;;; [(top-level-value)
+         ;;;  (let ([var (quoted-sym (cadr x))])
+         ;;;    (if (eq? (expand-mode) 'bootstrap)
+         ;;;        (if (primitive? var)
+         ;;;            (make-primref var)
+         ;;;            (error 'compile "invalid primitive ~s" var))
+         ;;;        (make-funcall
+         ;;;          (make-primref 'top-level-value)
+         ;;;          (list (make-constant var)))))]
+         [(set-top-level-value!)
+          (make-funcall (make-primref 'set-top-level-value!)
+                        (map (lambda (x) (E x env)) (cdr x)))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(recbind lhs* rhs* body) 
+       `(letrec ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(fix lhs* rhs* body) 
+       `(fix ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (make-recbind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+
+(define lambda-both 0)
+(define lambda-producer 0)
+(define lambda-consumer 0)
+(define lambda-none 0)
+(define branching-producer 0)
+
+
+(define (analyze-cwv x)
+  (define who 'analyze-cwv)
+  (define (lambda? x)
+    (record-case x
+      [(clambda) #t]
+      [else      #f]))
+  (define (branching-producer? x)
+    (define (bt? x)
+      (record-case x
+        [(bind lhs* rhs* body) (bt? body)]
+        [(recbind lhs* rhs* body) (bt? body)]
+        [(conditional test conseq altern) #t]
+        [(seq e0 e1) (bt? e1)]
+        [else #f]))
+    (define (branching-clause? x)
+      (record-case x 
+        [(clambda-case fml* proper body) 
+         (bt? body)]))
+    (record-case x
+      [(clambda cls*)
+       (ormap branching-clause? cls*)]
+      [else #f]))
+  (define (analyze producer consumer)
+    (cond
+      [(and (lambda? producer) (lambda? consumer))
+       (set! lambda-both (fxadd1 lambda-both))]
+      [(lambda? producer) 
+       (set! lambda-producer (fxadd1 lambda-producer))]
+      [(lambda? consumer)
+       (set! lambda-consumer (fxadd1 lambda-consumer))]
+      [else 
+       (set! lambda-none (fxadd1 lambda-none))])
+    (when (branching-producer? producer)
+      (set! branching-producer (fxadd1 branching-producer)))
+    (printf "both=~s p=~s c=~s none=~s branching-prod=~s\n"
+            lambda-both lambda-producer lambda-consumer lambda-none
+            branching-producer))
+  (define (E x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (for-each E rhs*) (E body)]
+      [(recbind lhs* rhs* body)
+       (for-each E rhs*) (E body)]
+      [(conditional test conseq altern)
+       (E test)
+       (E conseq)
+       (E altern)]
+      [(seq e0 e1) (E e0) (E e1)]
+      [(clambda cls*)
+       (for-each 
+         (lambda (x)
+           (record-case x
+             [(clambda-case fml* proper body) (E body)]))
+         cls*)]
+      [(primcall rator rand*) 
+       (for-each E rand*)
+       (when (and (eq? rator 'call-with-values) (fx= (length rand*) 2))
+         (analyze (car rand*) (cadr rand*)))]
+      [(funcall rator rand*)
+       (E rator) (for-each E rand*)
+       (when (and (record-case rator
+                    [(primref op) (eq? op 'call-with-values)]
+                    [else #f])
+                  (fx= (length rand*) 2))
+         (analyze (car rand*) (cadr rand*)))]
+      [(appcall rator rand*)
+       (E rator) (for-each E rand*)]
+      [(forcall rator rand*) 
+       (for-each E rand*)]
+      [(assign lhs rhs)
+       (E rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x))
+
+
+
+
+(define (optimize-letrec x)
+  (define who 'optimize-letrec)
+  (define (extend-hash lhs* h ref)
+    (for-each (lambda (lhs) (put-hash-table! h lhs #t)) lhs*)
+    (lambda (x)
+      (unless (get-hash-table h x #f)
+        (put-hash-table! h x #t)
+        (ref x))))
+  (define (E* x* ref comp)
+    (cond
+      [(null? x*) '()]
+      [else
+       (cons (E (car x*) ref comp)
+             (E* (cdr x*) ref comp))]))  
+  (define (do-rhs* i lhs* rhs* ref comp vref vcomp)
+    (cond
+      [(null? rhs*) '()]
+      [else
+       (let ([h (make-hash-table)])
+         (let ([ref
+                (lambda (x)
+                  (unless (get-hash-table h x #f)
+                    (put-hash-table! h x #t)
+                    (ref x)
+                    (when (memq x lhs*)
+                      (vector-set! vref i #t))))]
+               [comp
+                (lambda ()
+                  (vector-set! vcomp i #t)
+                  (comp))])
+           (cons (E (car rhs*) ref comp)
+                 (do-rhs* (fxadd1 i) lhs* (cdr rhs*) ref comp vref vcomp))))]))
+  (define (partition-rhs* i lhs* rhs* vref vcomp)
+    (cond
+      [(null? lhs*) (values '() '() '() '() '() '())]
+      [else
+       (let-values 
+         ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+           (partition-rhs* (fxadd1 i) (cdr lhs*) (cdr rhs*) vref vcomp)]
+          [(lhs rhs) (values (car lhs*) (car rhs*))])
+         (cond
+           [(var-assigned lhs) 
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [(clambda? rhs)
+            (values slhs* srhs* (cons lhs llhs*) (cons rhs lrhs*) clhs* crhs*)]
+           [(or (vector-ref vref i) (vector-ref vcomp i))
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [else
+            (values (cons lhs slhs*) (cons rhs srhs*) llhs* lrhs* clhs* crhs*)]
+           ))]))
+  (define (do-recbind lhs* rhs* body ref comp)
+    (let ([h (make-hash-table)]
+          [vref (make-vector (length lhs*) #f)]
+          [vcomp (make-vector (length lhs*) #f)])
+      (let* ([ref (extend-hash lhs* h ref)]
+             [body (E body ref comp)])
+        (let ([rhs* (do-rhs* 0 lhs* rhs* ref comp vref vcomp)])
+          (let-values ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+                        (partition-rhs* 0 lhs* rhs* vref vcomp)])
+            (let ([v* (map (lambda (x) (make-primcall 'void '())) clhs*)]
+                  [t* (map (lambda (x) (unique-var 'tmp)) clhs*)])
+              (make-bind slhs* srhs*
+                (make-bind clhs* v*
+                  (make-fix llhs* lrhs*
+                    (make-bind t* crhs*
+                      (build-assign* clhs* t* body)))))))))))
+  (define (build-assign* lhs* rhs* body)
+    (cond
+      [(null? lhs*)  body]
+      [else
+       (make-seq
+         (make-assign (car lhs*) (car rhs*))
+         (build-assign* (cdr lhs*) (cdr rhs*) body))]))
+  (define (E x ref comp)
+    (record-case x
+      [(constant) x]
+      [(var) (ref x) x]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (ref lhs)
+       (make-assign lhs (E rhs ref comp))]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let ([rhs* (E* rhs* ref comp)])
+         (let ([h (make-hash-table)])
+           (let ([body (E body (extend-hash lhs* h ref) comp)])
+             (make-bind lhs* rhs* body))))]
+      [(recbind lhs* rhs* body)
+       (if (null? lhs*)
+           (E body ref comp)
+           (do-recbind lhs* rhs* body ref comp))]
+      [(conditional e0 e1 e2)
+       (make-conditional (E e0 ref comp) (E e1 ref comp) (E e2 ref comp))]
+      [(seq e0 e1) (make-seq (E e0 ref comp) (E e1 ref comp))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (let ([h (make-hash-table)])
+                     (let ([body (E body (extend-hash fml* h ref) void)])
+                       (make-clambda-case fml* proper body)))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (when (memq rator '(call/cc call/cf))
+         (comp))
+       (make-primcall rator (E* rand* ref comp))]
+      [(funcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-funcall rator rand*))]
+      [(appcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-appcall rator rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (E* rand* ref comp))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x (lambda (x) (error who "free var ~s found" x))
+       void))
+
+
+(define (remove-letrec x)
+  (define who 'remove-letrec)
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (let ([t* (map (lambda (lhs) (unique-var 'tmp)) lhs*)]
+             [v* (map (lambda (lhs) (make-primcall 'void '())) lhs*)])
+         (make-bind lhs* v*
+           (make-bind t* (map Expr rhs*)
+             (let f ([lhs* lhs*] [t* t*])
+               (cond
+                 [(null? lhs*) (Expr body)]
+                 [else
+                  (make-seq
+                    (make-assign (car lhs*) (car t*))
+                    (f (cdr lhs*) (cdr t*)))])))))]
+      ;[(fix lhs* rhs* body)
+      ; (Expr (make-recbind lhs* rhs* body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (for-each Expr x*))
+  (define (Expr x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(recbind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(fix lhs* rhs* body)
+       (Expr* rhs*) 
+       (Expr body)
+       (when (ormap var-assigned lhs*)
+         (error 'uncover-assigned "a fix lhs is assigned"))]
+      [(conditional test conseq altern)
+       (begin (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (begin (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (for-each
+         (lambda (cls)
+           (Expr (clambda-case-body cls)))
+         cls*)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (Expr rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (rewrite-assignments x)
+  (define who 'rewrite-assignments)
+  (define (fix-lhs* lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* (cdr lhs*))])
+           (cond
+             [(var-assigned x)
+              (let ([t (unique-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(var-assigned x) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix-lhs* fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (var-assigned lhs)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+    (uncover-assigned x)
+    (rewrite-assignments x))
+  
+
+
+
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+   (define (do-clambda* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (do-clambda (car x*))]
+                    [(d d-free) (do-clambda* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (do-clambda x)
+    (record-case x 
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(fix lhs* rhs* body)
+       (let-values ([(rhs* rfree) (do-clambda* rhs*)]
+                    [(body bfree) (Expr body)])
+          (values (make-fix lhs* rhs* body)
+                  (difference (union bfree rfree) lhs*)))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(clambda)
+       (do-clambda ex)]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'positive) (fx> m 1)]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? $code? $forward-ptr? bwp-object?
+        pointer-value top-level-value car cdr list* list $record)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-size $code-reloc-vector $code-freevars 
+        $code-ref $code-set!
+        $make-record $record? $record/rtd? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+
+(define uninlined '())
+(define (mark-uninlined x)
+  (cond
+    [(assq x uninlined) =>
+     (lambda (p) (set-cdr! p (fxadd1 (cdr p))))]
+    [else (set! uninlined (cons (cons x 1) uninlined))]))
+
+(module ()
+  (primitive-set! 'uninlined-stats 
+    (lambda () 
+      (let f ([ls uninlined] [ac '()])
+        (cond
+          [(null? ls) ac]
+          [(fx> (cdar ls) 15)
+           (f (cdr ls) (cons (car ls) ac))]
+          [else (f (cdr ls) ac)])))))
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (when (primref? rator)
+            (mark-uninlined (primref-name rator)))
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (cond
+         [(memq op '(not car cdr))
+          (make-primcall op (map Expr arg*))]
+         [else
+          (simplify* arg* '() '()
+            (lambda (arg* lhs* rhs*)
+              (make-bind^ lhs* rhs* 
+                (make-primcall op arg*))))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body) (Expr body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body) (Tail body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-forcall "ik_collect" ;(make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant (fx+ n 4096)) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-forcall "ik_collect" ; (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant (fx+ n 4096)) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-forcall "ik_collect" ;(make-primref 'do-overflow) 
+                      (list (make-constant (fx+ n 4096))))
+        (make-primcall 'void '()))
+      body))
+  (define (closure-size x)
+    (record-case x 
+      [(closure code free*)
+       (align (fx+ disp-closure-data (fx* (length free*) wordsize)))]
+      [else (error 'closure-size "~s is not a closure" x)]))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) 
+       (check-const (closure-size x) x)]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Expr body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Expr body))))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(list*)
+            (check-const (fx* (fxsub1 (length arg*)) pair-size) x)]
+           [(list)
+            (check-const (fx* (length arg*) pair-size) x)]
+           [(vector $record)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Tail body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Tail body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+              
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (check? x)
+    (cond
+      [(primref? x) #f]  ;;;; PRIMREF CHECK
+      [else         #t]))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp (check? op) (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" call-convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (do-closure r)
+    (lambda (x)
+      (record-case x
+        [(closure code free*)
+         (make-closure code (simple* free* r))])))
+  (define (do-fix lhs* rhs* body si r live k)
+    (let f ([l* lhs*] [nlhs* '()] [si si] [r r] [live live])
+      (cond
+        [(null? l*) 
+         (make-fix (reverse nlhs*) 
+                   (map (do-closure r) rhs*)
+                   (k body si r live))]
+        [else
+         (let ([v (make-frame-var si)])
+           (f (cdr l*) (cons v nlhs*) (fxadd1 si) 
+              (cons (cons (car l*) v) r)
+              (cons si live)))])))
+  (define (do-tail-frame-old op rand* si r call-conv live)
+    (define (const? x)
+      (record-case x
+        [(constant) #t]
+        [(primref)  #t]
+        [else       #f]))
+    (define (evalrand* rand* i si r live)
+      (cond
+        [(null? rand*) 
+         (make-eval-cp (check? op) (Expr op si r live))]
+        [(const? (car rand*))
+         (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r live)]
+        [else
+         (let ([v (make-frame-var si)]
+               [rhs (Expr (car rand*) si r live)])
+           (cond
+             [(and (frame-var? rhs)
+                   (fx= (frame-var-idx rhs) i))
+              (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r (cons si live))]
+             [else
+              (make-seq
+                (make-assign v rhs)
+                (evalrand* (cdr rand*) (fx+ 1 i) (fx+ 1 si) r
+                           (cons si live)))]))]))
+    (define (moverand* rand* i si ac)
+      (cond
+        [(null? rand*) ac]
+        [(const? (car rand*))
+         (make-seq
+           (make-assign (make-frame-var i) (car rand*))
+           (moverand* (cdr rand*) (fxadd1 i) (fxadd1 si) ac))]
+        [else
+         (make-seq
+           (make-assign (make-frame-var i) (make-frame-var si))
+           (moverand* (cdr rand*) (fxadd1 i) (fxadd1 si) ac))]))
+    (make-seq
+      (evalrand* rand* 1 si r live)
+      (moverand* rand* 1 si
+        (make-tailcall-cp call-conv (length rand*))))) 
+  (define (do-tail-frame op rand* si r call-conv live)
+    (define (const? x)
+      (record-case x
+        [(constant) #t]
+        [(primref)  #t]
+        [else       #f]))
+    (define (evalrand* rand* i si r live ac)
+      (cond
+        [(null? rand*) 
+         (make-seq
+           (make-eval-cp (check? op) (Expr op si r live))
+           ac)]
+        [(const? (car rand*))
+         (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r live
+           (make-seq ac
+             (make-assign (make-frame-var i) (car rand*))))]
+        [else
+         (let ([vsi (make-frame-var si)]
+               [rhs (Expr (car rand*) si r live)])
+           (cond
+             [(and (frame-var? rhs)
+                   (fx= (frame-var-idx rhs) i))
+              (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r (cons si live) ac)]
+             [(fx= i si)
+              (make-seq 
+                (make-assign vsi rhs)
+                (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r
+                           (cons si live) ac))]
+             [else
+              (make-seq
+                (make-assign vsi rhs)
+                (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r (cons si live)
+                  (make-seq ac
+                    (make-assign (make-frame-var i) vsi))))]))]))
+    (make-seq
+      (evalrand* rand* 1 si r live (make-primcall 'void '()))
+      (make-tailcall-cp call-conv (length rand*))))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (make-return 
+         (make-primcall op 
+           (map (lambda (x) (Expr x si r live)) arg*)))]
+                                  
+      [(funcall op rand*)
+       (do-tail-frame op rand* si r 'normal live)]
+      [(appcall op rand*)
+       (do-tail-frame op rand* si r 'apply live)]
+;;;      [(funcall op rand*)
+;;;       (do-new-frame op rand* si r 'normal 'tail live)]
+;;;      [(appcall op rand*)
+;;;       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op 
+         (map (lambda (x) (Expr x si r live)) arg*))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op 
+         (map (lambda (x) (Expr x si r live)) arg*))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+
+
+
+(define checks-elim-count 0)
+(define (optimize-ap-check x)
+  (define who 'optimize-ap-check)
+  (define (min x y)
+    (if (fx< x y) x y))
+  (define (Tail x f)
+    (record-case x
+      [(return v)
+       (let-values ([(v f) (NonTail v f)])
+         (make-return v))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* rhs* (Tail body f))]
+      [(conditional test conseq altern)
+       (let-values ([(test f) (NonTail test f)])
+         (make-conditional 
+           test
+           (Tail conseq f)
+           (Tail altern f)))]
+      [(seq e0 e1) 
+       (let-values ([(e0 f) (NonTail e0 f)])
+         (make-seq e0 (Tail e1 f)))]
+      [(tailcall-cp) x]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (do-primcall op arg* f)
+    (case op
+      [($ap-check-const)
+       (let ([n (constant-value (car arg*))])
+         (cond
+           [(fx< n f) 
+            ;(set! checks-elim-count (fxadd1 checks-elim-count))
+            ;(printf "~s checks eliminated\n" checks-elim-count)
+            (values (make-constant #f) (fx- f n))]
+           [(fx<= n 4096)
+            (values (make-primcall '$ap-check-const 
+                                   (list (make-constant 4096)))
+                    (fx- 4096 n))]
+           [else
+            (values (make-primcall '$ap-check-const 
+                                   (list (make-constant (fx+ n 4096))))
+                    4096)]))]
+      [($ap-check-bytes $ap-check-words)
+       (values (make-primcall op 
+                 (list (make-constant (fx+ (constant-value (car arg*)) 
+                                           4096))
+                       (cadr arg*)))
+               4096)]
+      [else (values (make-primcall op arg*) f)]))
+  (define (NonTail x f)
+    (record-case x
+      [(constant)         (values x f)]
+      [(frame-var)        (values x f)]
+      [(cp-var)           (values x f)]
+      [(save-cp)          (values x f)]
+      [(foreign-label)    (values x f)]
+      [(primref)          (values x f)]
+      [(closure)          (values x f)]
+      [(call-cp call-conv) 
+       (if (eq? call-conv 'foreign)
+           (values x f)
+           (values x 0))]
+      [(primcall op arg*) (do-primcall op arg* f)]
+      [(fix lhs* rhs* body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-fix lhs* rhs* body) f))]
+      [(conditional test conseq altern)
+       (let-values ([(test f) (NonTail test f)])
+         (if (constant? test)
+             (if (constant-value test)
+                 (NonTail conseq f)
+                 (NonTail altern f))
+             (let-values ([(conseq f0) (NonTail conseq f)]
+                          [(altern f1) (NonTail altern f)])
+               (values (make-conditional test conseq altern)
+                       (min f0 f1)))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 f) (NonTail e0 f)])
+         (let-values ([(e1 f) (NonTail e1 f)])
+           (values (make-seq e0 e1) f)))]
+      [(assign lhs rhs)
+       (let-values ([(rhs f) (NonTail rhs f)])
+         (values (make-assign lhs rhs) f))]
+      [(eval-cp check body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-eval-cp check body) f))]
+      [(new-frame base-idx size body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-new-frame base-idx size body) f))]
+      [else (error who "invalid nontail expression ~s" (unparse x))]))
+  (define CaseExpr 
+    (lambda (x)
+      (record-case x 
+        [(clambda-case fml* proper body)
+         (make-clambda-case fml* proper (Tail body 0))])))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 0))]))
+  (CodesExpr x))
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag #x2F)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-freevars      12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+  (define record-ptag  5)
+  (define record-pmask 7)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define dirty-word -1))
+
+(define (align n)
+  (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (Pred (car rand*) Lf Lt ac)]
+     ;[(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [($record/rtd?)
+      (cond
+        [Lf
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int vector-mask) eax)
+                (cmpl (int vector-tag) eax)
+                (jne Lf)
+                (movl (Simple (cadr rand*)) eax)
+                (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                (jne Lf)
+                (if Lt
+                    (cons (jmp Lt) ac)
+                    ac))]
+        [Lt
+         (let ([Ljoin (unique-label)])
+           (list* (movl (Simple (car rand*)) eax)
+                  (movl eax ebx)
+                  (andl (int vector-mask) eax)
+                  (cmpl (int vector-tag) eax)
+                  (jne Ljoin)
+                  (movl (Simple (cadr rand*)) eax)
+                  (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                  (je Lt)
+                  Ljoin
+                  ac))]
+        [else ac])]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx<= i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref top-level-value car cdr $record-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [(car cdr)
+       (let ([x (car arg*)])
+         (NonTail x
+           (list* 
+             (movl eax ebx)
+             (andl (int pair-mask) eax)
+             (cmpl (int pair-tag) eax)
+             (if (eq? op 'car)
+                 (list* 
+                   (jne (label SL_car_error))
+                   (movl (mem (fx- disp-car pair-tag) ebx) eax)
+                   ac)
+                 (list* 
+                   (jne (label SL_cdr_error))
+                   (movl (mem (fx- disp-cdr pair-tag) ebx) eax)
+                   ac)))))]
+      [(top-level-value)
+       (let ([x (car arg*)])
+         (cond
+           [(constant? x)
+            (let ([v (constant-value x)])
+              (cond
+                [(symbol? v)
+                 (list* 
+                   (movl (mem (fx- disp-symbol-value symbol-tag) (obj v)) eax)
+                   (movl (obj v) ebx)
+                   (cmpl (int unbound) eax)
+                   (je (label SL_top_level_value_error))
+                   ac)]
+                [else
+                 (list* 
+                   (movl (obj v) ebx)
+                   (jmp (label SL_top_level_value_error))
+                   ac)]))]
+           [else
+            (NonTail x
+              (list* 
+                (movl eax ebx)
+                (andl (int symbol-mask) eax)
+                (cmpl (int symbol-tag) eax)
+                (jne (label SL_top_level_value_error))
+                (movl (mem (fx- disp-symbol-value symbol-tag) ebx) eax)
+                (cmpl (int unbound) eax)
+                (je (label SL_top_level_value_error))
+                ac))]))]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($code-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int 0) eax)
+              (movb (mem (fx- disp-code-data vector-tag) ebx) ah)
+              (sarl (int (fx- 8 fx-shift)) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [(list)
+       (cond
+         [(null? arg*) (NonTail (make-constant '()) ac)]
+         [else
+          (list*
+            (addl (int pair-tag) apr)
+            (movl apr eax)
+            (let f ([a (car arg*)] [d (cdr arg*)])
+              (list*
+                (movl (Simple a) ebx)
+                (movl ebx (mem (fx- disp-car pair-tag) apr))
+                (if (null? d)
+                    (list*
+                      (movl (int nil) (mem (fx- disp-cdr pair-tag) apr))
+                      (addl (int (fx- pair-size pair-tag)) apr)
+                      ac)
+                    (list*
+                      (addl (int pair-size) apr)
+                      (movl apr 
+                          (mem (fx- disp-cdr (fx+ pair-tag pair-size)) apr))
+                      (f (car d) (cdr d)))))))])]
+      [(list*)
+       (cond
+         [(fx= (length arg*) 1) (NonTail (car arg*) ac)]
+         [(fx= (length arg*) 2) (NonTail (make-primcall 'cons arg*) ac)]
+         [else
+          (list*
+            (addl (int pair-tag) apr)
+            (movl apr eax)
+            (let f ([a (car arg*)] [b (cadr arg*)] [d (cddr arg*)])
+              (list*
+                (movl (Simple a) ebx)
+                (movl ebx (mem (fx- disp-car pair-tag) apr))
+                (if (null? d)
+                    (list*
+                      (movl (Simple b) ebx)
+                      (movl ebx (mem (fx- disp-cdr pair-tag) apr))
+                      (addl (int (fx- pair-size pair-tag)) apr)
+                      ac)
+                    (list*
+                      (addl (int pair-size) apr)
+                      (movl apr 
+                          (mem (fx- disp-cdr (fx+ pair-tag pair-size)) apr))
+                      (f b (car d) (cdr d)))))))])]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [($record) 
+       (let ([rtd (car arg*)]
+             [ac 
+              (let f ([arg* (cdr arg*)] [idx disp-record-data])
+                (cond
+                  [(null? arg*) 
+                   (list* (movl apr eax)
+                          (addl (int vector-tag) eax)
+                          (addl (int (align idx)) apr)
+                          ac)]
+                  [else 
+                   (list* (movl (Simple (car arg*)) eax)
+                          (movl eax (mem idx apr))
+                          (f (cdr arg*) (fx+ idx wordsize)))]))])
+         (cond
+           [(constant? rtd)
+            (list* (movl (Simple rtd) (mem 0 apr)) ac)]
+           [else
+            (list* (movl (Simple rtd) eax) (movl eax (mem 0 apr)) ac)]))]
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag)  ac)]
+     [($code-reloc-vector) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-freevars) 
+       (indirect-ref arg* (fx- disp-code-freevars vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $code-set!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? $code? 
+       $record? $record/rtd? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($code-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (sall (int (fx- 8 fx-shift)) ebx)
+              (movb bh (mem (fx- disp-code-data vector-tag) eax))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1 $record-ref)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (closure-size x)
+    (align (fx+ disp-closure-data
+                (fx* wordsize (length (closure-free* x))))))
+  (define (assign-codes rhs* n* i ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (record-case (car rhs*)
+         [(closure label free*)
+          (cons (movl (Simple label) (mem i apr))
+                (assign-codes 
+                  (cdr rhs*) (cdr n*) (fx+ i (car n*)) ac))])]))
+  (define (whack-free x i n* rhs* ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let ([free (closure-free* (car rhs*))])
+         (let f ([free free] [j (fx+ i disp-closure-data)])
+           (cond
+             [(null? free) 
+              (whack-free x (fx+ i (car n*)) (cdr n*) (cdr rhs*) ac)]
+             [(eq? (car free) x)
+              (cons
+                (movl eax (mem j apr))
+                (f (cdr free) (fx+ j wordsize)))]
+             [else (f (cdr free) (fx+ j wordsize))])))]))
+  (define (assign-nonrec-free* rhs* all-rhs* n* seen ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let f ([ls (closure-free* (car rhs*))] [seen seen])
+         (cond
+           [(null? ls) 
+            (assign-nonrec-free* (cdr rhs*) all-rhs* n* seen ac)]
+           [(memq (car ls) seen) (f (cdr ls) seen)]
+           [else
+            (cons
+              (movl (Simple (car ls)) eax)
+              (whack-free (car ls) 0 n* all-rhs*
+                (f (cdr ls) (cons (car ls) seen))))]))]))
+  (define (assign-rec-free* lhs* rhs* all-n* ac)
+    (list* (movl apr eax)
+           (addl (int closure-tag) eax)
+           (let f ([lhs* lhs*] [n* all-n*])
+             (cond
+               [(null? (cdr lhs*)) 
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs* ac))]
+               [else
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs*
+                    (cons
+                      (addl (int (car n*)) eax)
+                      (f (cdr lhs*) (cdr n*)))))]))))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (do-fix lhs* rhs* ac)
+    ;;; 1. first, set the code pointers in the right places
+    ;;; 2. next, for every variable appearing in the rhs* but is not in
+    ;;;    the lhs*, load it once and set it everywhere it occurs.
+    ;;; 3. next, compute the values of the lhs*, and for every computed
+    ;;;    value, store it on the stack, and set it everywhere it occurs
+    ;;;    in the rhs*
+    ;;; 4. that's it.
+    (let* ([n* (map closure-size rhs*)])
+      (assign-codes rhs* n* 0
+        (assign-nonrec-free* rhs* rhs* n* lhs*
+          (assign-rec-free* lhs* rhs* n*
+            (cons (addl (int (sum 0 n*)) apr) ac))))))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* (NonTail body ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else
+            (error who "invalid convention ~s for call-cp" call-convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Pred body Lt Lf ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let* ([Ljoin (unique-label)]
+             [ac (cons Ljoin ac)]
+             [altern-ac (Effect altern ac)])
+        (cond
+          [(eq? altern-ac ac) ;; altern is nop
+           (let* ([conseq-ac (Effect conseq ac)])
+             (cond
+               [(eq? conseq-ac ac) ;; conseq is nop too!
+                (Effect test ac)]
+               [else  ; "when" pattern
+                (Pred test #f Ljoin conseq-ac)]))]
+          [else 
+           (let* ([Lf (unique-label)]
+                  [nac (list* (jmp Ljoin) Lf altern-ac)]
+                  [conseq-ac (Effect conseq nac)])
+             (cond
+               [(eq? conseq-ac nac) ;; "unless" pattern"
+                (Pred test Ljoin #f altern-ac)]
+               [else
+                (Pred test #f Lf conseq-ac)]))]))]
+;;;  [(conditional test conseq altern)
+;;;   (let ([Lf (unique-label)] [Ljoin (unique-label)])
+;;;     (Pred test #f Lf
+;;;       (Effect conseq
+;;;         (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Effect body ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (record-case val
+           [(constant c) 
+            (cons (movl (constant-val c) (idx->frame-loc i)) ac)]
+           [else
+            (NonTail val
+              (cons (movl eax (idx->frame-loc i)) ac))])]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (cond
+        [check
+         (NonTail body
+           (list* 
+             (movl eax cpr)
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac))]
+        [(primref? body)
+         (list* (movl (primref-loc (primref-name body)) cpr) ac)]
+        [else
+         (NonTail body (list* (movl eax cpr) ac))])]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Tail body ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(tailcall-cp call-convention argc)
+      (list* 
+        (movl (int (argc-convention argc)) eax)
+        (case call-convention
+          [(normal) (tail-indirect-cpr-call)]
+          [(apply)  (jmp (label SL_apply))]
+          [else 
+           (error who "invalid tail-call convention ~s" call-convention)])
+        ac)]
+;;;     [(call-cp call-convention rp-convention idx argc mask)
+;;;      (unless (eq? rp-convention 'tail)
+;;;        (error who "nontail rp (~s) in tail context" rp-convention))
+;;;      (let f ([i 0])
+;;;        (cond
+;;;          [(fx= i argc)
+;;;           (case call-convention
+;;;             [(normal) 
+;;;              (list* 
+;;;                (movl (int (argc-convention argc)) eax)
+;;;                (tail-indirect-cpr-call)
+;;;                ac)]
+;;;             [(apply)
+;;;              (list* 
+;;;                (movl (int (argc-convention argc)) eax)
+;;;                (jmp (label SL_apply)) 
+;;;                ac)]
+;;;             [else
+;;;              (error who "invalid conv ~s in tail call-cpr" call-convention)])]
+;;;          [else
+;;;            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+;;;                                   (fx- 0 wordsize)) fpr)
+;;;                         eax)
+;;;                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+;;;                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (length free)
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+
+(define SL_top_level_value_error (gensym "SL_top_level_value_error"))
+(define SL_car_error (gensym "SL_car_error"))
+(define SL_cdr_error (gensym "SL_cdr_error"))
+
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(module ()
+(list*->code*
+  (list
+    (list 0
+          (label SL_car_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'car-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_cdr_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'cdr-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_top_level_value_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'top-level-value-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list 
+          0 ; no free vars
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list 0 ; no freevars
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list  1 ; freevars
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    )))
+
+
+
+(define (compile-expr expr)
+  (let* ([p (recordize expr)]
+         [p (optimize-direct-calls p)]
+;;;         [foo (analyze-cwv p)]
+         [p (optimize-letrec p)]
+         ;[p (remove-letrec p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         [p (optimize-ap-check p)]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (car code*)))
+
+(define compile-file
+  (lambda (input-file output-file . rest)
+    (let ([ip (open-input-file input-file)]
+          [op (apply open-output-file output-file rest)])
+      (let f ()
+        (let ([x (read ip)])
+          (unless (eof-object? x)
+            (fasl-write (compile-expr (expand x)) op)
+            (f))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+(primitive-set! 'compile-file compile-file)
+(primitive-set! 'assembler-output (make-parameter #f))
+(primitive-set! 'compile
+  (lambda (x)
+    (let ([code (compile-expr (expand x))])
+      (let ([proc ($code->closure code)])
+        (proc)))))
+
+)
+
diff --git a/src/libcompile-8.1.ss b/src/libcompile-8.1.ss
new file mode 100644
index 0000000..b25dcf3
--- /dev/null
+++ b/src/libcompile-8.1.ss
@@ -0,0 +1,3677 @@
+
+;;; 6.7: * open-coded top-level-value, car, cdr
+;;; 6.2: * side-effects now modify the dirty-vector
+;;;      * added bwp-object?
+;;;      * added pointer-value
+;;;      * added tcbuckets
+;;; 6.1: * added case-lambda, dropped lambda
+;;; 6.0: * basic compiler
+
+(let ()
+
+(define-syntax cond-expand
+  (lambda (x)
+    (syntax-case x ()
+      [(_ test conseq altern)
+       (if (eval (syntax-object->datum #'test))
+           #'conseq
+           #'altern)])))
+
+(cond-expand (eq? "" "")
+  (include "record-case.chez.ss")
+  (include "record-case.ss"))
+
+
+(include "set-operations.ss")
+
+
+(define open-coded-primitives
+;;; these primitives, when found in operator position with the correct
+;;; number of arguments, will be open-coded by the generator.  If an 
+;;; incorrect number of args is detected, or if they appear in non-operator
+;;; position, then they cannot be open-coded, and the pcb-primitives table
+;;; is consulted for a reference of the pcb slot containing the primitive.
+;;; If it's not found there, an error is signalled.
+;;;
+;;; prim-name          args
+  '([$constant-ref      1   value]
+    [$constant-set!     2   effect]
+    [$pcb-ref           1   value]
+    [$pcb-set!          2   effect]
+    ;;; type predicates
+    [fixnum?            1   pred]
+    [immediate?         1   pred]
+    [boolean?           1   pred]
+    [char?              1   pred]
+    [pair?              1   pred]
+    [symbol?            1   pred]
+    [vector?            1   pred]
+    [string?            1   pred]
+    [procedure?         1   pred]
+    [null?              1   pred]
+    [eof-object?        1   pred]
+    [bwp-object?        1   pred]
+    [$unbound-object?   1   pred]
+    [$forward-ptr?      1   pred]
+    [not                1   pred]
+    [pointer-value      1  value]
+    [eq?                2   pred]
+    ;;; fixnum primitives
+    [$fxadd1            1   value]
+    [$fxsub1            1   value]
+    [$fx+               2   value]
+    [$fx-               2   value]
+    [$fx*               2   value]
+    [$fxsll             2   value]
+    [$fxsra             2   value]
+    [$fxlogand          2   value]
+    [$fxlogor           2   value]
+    [$fxlogxor          2   value]
+    [$fxlognot          1   value]
+    [$fxquotient        2   value]
+    [$fxmodulo          2   value]
+    ;;; fixnum predicates
+    [$fxzero?           1   pred]
+    [$fx=               2   pred]
+    [$fx<               2   pred]
+    [$fx<=              2   pred]
+    [$fx>               2   pred]
+    [$fx>=              2   pred]
+    ;;; character predicates
+    [$char=             2   pred]
+    [$char<             2   pred]
+    [$char<=            2   pred]
+    [$char>             2   pred]
+    [$char>=            2   pred]
+    ;;; character conversion
+    [$fixnum->char      1   value]
+    [$char->fixnum      1   value]
+    ;;; lists/pairs
+    [cons               2   value]
+    [list*         positive value]
+    [list             any   value]
+    [car                1   value]
+    [cdr                1   value]
+    [$car               1   value]
+    [$cdr               1   value]
+    [$set-car!          2   effect]
+    [$set-cdr!          2   effect]
+    ;;; vectors
+    [$make-vector       1   value]
+    [vector           any   value]
+    [$vector-length     1   value]
+    [$vector-ref        2   value]
+    [$vector-set!       3   effect]
+    [$vector-memq       2   value]
+    ;;; strings
+    [$make-string       1   value]
+    [$string          any   value]
+    [$string-length     1   value]
+    [$string-ref        2   value]
+    [$string-set!       3   effect]
+    ;;; symbols
+    [$make-symbol       1   value]
+    [$symbol-value      1   value]
+    [$symbol-string     1   value]
+    [$symbol-unique-string     1   value]
+    [$set-symbol-value! 2   effect]
+    [$set-symbol-string! 2   effect]
+    [$set-symbol-unique-string! 2   effect]
+    [$symbol-plist      1   value]
+    [$set-symbol-plist! 2   effect]
+    [primitive-ref 1 value]
+    [primitive-set! 2 effect]
+    [top-level-value      1   value]
+    ;;; ports
+    [port?                    1 pred]
+    [input-port?              1 pred]
+    [output-port?             1 pred]
+    [$make-port               7 value]
+    [$port-handler            1 value]
+    [$port-input-buffer       1 value]
+    [$port-input-index        1 value]
+    [$port-input-size         1 value]
+    [$port-output-buffer      1 value]
+    [$port-output-index       1 value]
+    [$port-output-size        1 value]
+    [$set-port-input-index!   2 effect]
+    [$set-port-input-size!    2 effect]
+    [$set-port-output-index!  2 effect]
+    [$set-port-output-size!   2 effect]
+    ;;; tcbuckets
+    [$make-tcbucket       4   value]
+    [$tcbucket-key        1   value]
+    [$tcbucket-val        1   value]
+    [$tcbucket-next       1   value]
+    [$set-tcbucket-val!   2  effect]
+    [$set-tcbucket-next!  2  effect]
+    [$set-tcbucket-tconc! 2  effect]
+    ;;; misc
+    [eof-object         0   value]
+    [void               0   value]
+    [$exit              1   effect]
+    [$fp-at-base        0   pred]
+    [$current-frame     0   value]
+    [$seal-frame-and-call 1  tail]
+    [$frame->continuation 1 value]
+    ;;; 
+    ;;; records
+    ;;;
+    [$make-record       2   value]
+    [$record?           1    pred]
+    [$record/rtd?       2    pred]
+    [$record-rtd        1   value]
+    [$record-ref        2   value]
+    [$record-set!       3  effect]
+    [$record          any   value]
+    ;;;
+    ;;; asm
+    ;;;
+    [$code?              1    pred]
+    [$code-size          1    value]
+    [$code-reloc-vector  1    value]
+    [$code-freevars      1    value]
+    [$code-ref           2    value]
+    [$code-set!          3    value]
+    [$code->closure      1    value]
+    ;;;
+    [$make-call-with-values-procedure 0 value]
+    [$make-values-procedure 0 value]
+    [$install-underflow-handler 0 effect]
+   ))
+
+(define (primitive-context x)
+  (cond
+    [(assq x open-coded-primitives) => caddr]
+    [else (error 'primitive-context "unknown prim ~s" x)]))
+
+(define (open-codeable? x)
+  (cond
+    [(assq x open-coded-primitives) #t]
+    [else  #f]))
+
+(define (open-coded-primitive-args x)
+  (cond
+    [(assq x open-coded-primitives) => cadr]
+    [else (error 'open-coded-primitive-args "invalid ~s" x)]))
+
+;;; end of primitives table section
+
+  
+(define-record constant (value))
+(define-record code-loc (label))
+(define-record foreign-label (label))
+(define-record var (name assigned))
+(define-record cp-var (idx))
+(define-record frame-var (idx))
+(define-record new-frame (base-idx size body))
+(define-record save-cp (loc))
+(define-record eval-cp (check body))
+(define-record return (value))
+(define-record call-cp
+  (call-convention rp-convention base-idx arg-count live-mask))
+(define-record tailcall-cp (convention arg-count))
+(define-record primcall (op arg*))
+(define-record primref (name))
+(define-record conditional (test conseq altern))
+(define-record bind (lhs* rhs* body))
+(define-record recbind (lhs* rhs* body))
+(define-record fix (lhs* rhs* body))
+
+(define-record seq (e0 e1))
+(define-record clambda-case (arg* proper body))
+(define-record clambda (cases))
+(define-record clambda-code (label cases free))
+(define-record closure (code free*))
+(define-record funcall (op rand*))
+(define-record appcall (op rand*))
+(define-record forcall (op rand*))
+(define-record code-rec (arg* proper free* body))
+(define-record codes (list body))
+(define-record assign (lhs rhs))
+
+(define (unique-var x)
+  (make-var (gensym (symbol->string x)) #f))
+
+
+(define (make-bind^ lhs* rhs* body)
+  (if (null? lhs*)
+      body
+      (make-bind lhs* rhs* body)))
+
+(define (recordize x)
+  (define (gen-fml* fml*)
+    (cond
+      [(pair? fml*)
+       (cons (unique-var (car fml*))
+             (gen-fml* (cdr fml*)))]
+      [(symbol? fml*)
+       (unique-var fml*)]
+      [else '()]))
+  (define (properize fml*)
+    (cond
+      [(pair? fml*)
+       (cons (car fml*) (properize (cdr fml*)))]
+      [(null? fml*) '()]
+      [else (list fml*)]))
+  (define (extend-env fml* nfml* env)
+    (cons (cons fml* nfml*) env))
+  (define (quoted-sym x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (symbol? (cadr x)))
+        (cadr x)
+        (error 'quoted-sym "not a quoted symbol ~s" x)))
+   (define (quoted-string x)
+    (if (and (list? x)
+             (fx= (length x) 2)
+             (eq? 'quote (car x))
+             (string? (cadr x)))
+        (cadr x)
+        (error 'quoted-string "not a quoted string ~s" x)))
+  (define (lookup^ x lhs* rhs*)
+    (cond
+      [(pair? lhs*)
+       (if (eq? x (car lhs*))
+           (car rhs*)
+           (lookup^ x (cdr lhs*) (cdr rhs*)))]
+      [(eq? x lhs*) rhs*]
+      [else #f]))
+  (define (lookup x env)
+    (cond
+      [(pair? env)
+       (or (lookup^ x (caar env) (cdar env))
+           (lookup x (cdr env)))]
+      [else #f]))
+  (define (E x env)
+    (cond
+      [(pair? x)
+       (case (car x)
+         [(quote)  (make-constant (cadr x))]
+         [(if) 
+          (make-conditional 
+            (E (cadr x) env)
+            (E (caddr x) env)
+            (E (cadddr x) env))]
+         [(set!)
+          (let ([lhs (cadr x)] [rhs (caddr x)])
+            (make-assign
+              (or (lookup lhs env) 
+                  (error 'recordize "invalid assignment ~s" x))
+              (E rhs env)))]
+         [(begin)
+          (let f ([a (cadr x)] [d (cddr x)])
+            (cond
+              [(null? d) (E a env)]
+              [else
+               (make-seq 
+                 (E a env)
+                 (f (car d) (cdr d)))]))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)])
+              (let ([nlhs* (gen-fml* lhs*)])
+                (let ([env (extend-env lhs* nlhs* env)])
+                  (make-recbind nlhs* 
+                                (map (lambda (rhs) (E rhs env)) rhs*)
+                                (E body env))))))]
+         [(letrec)
+          (unless (fx= (length x) 3) (syntax-error x))
+          (let ([bind* (cadr x)] [body (caddr x)])
+            (let ([lhs* (map car bind*)]
+                  [rhs* (map cadr bind*)]
+                  [v* (map (lambda (x) '(void)) bind*)]
+                  [t* (map (lambda (x) (gensym)) bind*)])
+              (E `((case-lambda 
+                     [,lhs* 
+                       ((case-lambda 
+                          [,t* 
+                           (begin ,@(map (lambda (x v) `(set! ,x ,v)) lhs* t*)
+                                  ,body)])
+                        ,@rhs*)])
+                   ,@v*)
+                 env)))]
+         [(case-lambda)
+          (let ([cls*
+                 (map
+                   (lambda (cls)
+                     (let ([fml* (car cls)] [body (cadr cls)])
+                       (let ([nfml* (gen-fml* fml*)])
+                         (let ([body (E body (extend-env fml* nfml* env))])
+                           (make-clambda-case 
+                             (properize nfml*) 
+                             (list? fml*) 
+                             body)))))
+                   (cdr x))])
+            (make-clambda cls*))]
+         [(foreign-call)
+          (let ([name (quoted-string (cadr x))] [arg* (cddr x)])
+            (make-forcall name
+              (map (lambda (x) (E x env)) arg*)))]
+         [(|#primitive|)
+          (let ([var (cadr x)])
+            (make-primref var))]
+         ;;; [(|#primitive|)
+         ;;;  (let ([var (cadr x)])
+         ;;;    (if (primitive? var)
+         ;;;        (make-primref var)
+         ;;;        (error 'recordize "invalid primitive ~s" var)))]
+         [(top-level-value)
+          (let ([var (quoted-sym (cadr x))])
+            (if (eq? (expand-mode) 'bootstrap)
+                ;(error 'compile "reference to ~s in bootstrap mode" var)
+                (make-primref var)
+                (make-funcall
+                  (make-primref 'top-level-value)
+                  (list (make-constant var)))))]
+         ;;; [(top-level-value)
+         ;;;  (let ([var (quoted-sym (cadr x))])
+         ;;;    (if (eq? (expand-mode) 'bootstrap)
+         ;;;        (if (primitive? var)
+         ;;;            (make-primref var)
+         ;;;            (error 'compile "invalid primitive ~s" var))
+         ;;;        (make-funcall
+         ;;;          (make-primref 'top-level-value)
+         ;;;          (list (make-constant var)))))]
+         [(set-top-level-value!)
+          (make-funcall (make-primref 'set-top-level-value!)
+                        (map (lambda (x) (E x env)) (cdr x)))]
+         [(memv) 
+          (make-funcall
+             (make-primref 'memq)
+             (map (lambda (x) (E x env)) (cdr x)))]
+         [($apply)
+          (let ([proc (cadr x)] [arg* (cddr x)])
+            (make-appcall
+              (E proc env)
+              (map (lambda (x) (E x env)) arg*)))]
+         [(void) 
+          (make-constant (void))]
+         [else
+          (make-funcall 
+            (E (car x) env)
+            (map (lambda (x) (E x env)) (cdr x)))])]
+      [(symbol? x)
+       (or (lookup x env)
+           (error 'recordize "invalid reference in ~s" x))]
+      [else (error 'recordize "invalid expression ~s" x)]))
+  (E x '()))
+
+
+(define (unparse x)
+  (define (E-args proper x)
+    (if proper 
+        (map E x)
+        (let f ([a (car x)] [d (cdr x)])
+          (cond
+            [(null? d) (E a)]
+            [else (cons (E a) (f (car d) (cdr d)))]))))
+  (define (E x)
+    (record-case x
+      [(constant c) `(quote ,c)]
+      [(code-loc x) `(code-loc ,x)]
+      [(var x) (string->symbol (format "v:~a" x))]
+      [(primref x) x]
+      [(conditional test conseq altern) 
+       `(if ,(E test) ,(E conseq) ,(E altern))]
+      [(primcall op arg*) `(,op . ,(map E arg*))]
+      [(bind lhs* rhs* body) 
+       `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(recbind lhs* rhs* body) 
+       `(letrec ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(fix lhs* rhs* body) 
+       `(fix ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*)
+          ,(E body))]
+      [(seq e0 e1) `(begin ,(E e0) ,(E e1))]
+      [(clambda-case args proper body)
+       `(clambda-case ,(E-args proper args) ,(E body))]
+      [(clambda cls*)
+       `(case-lambda . ,(map E cls*))]
+      [(clambda-code label clauses free)
+       `(code ,label . ,(map E clauses))]
+      [(closure code free*)
+       `(closure ,(E code) ,(map E free*))]
+      [(code-rec arg* proper free* body) 
+       `(code-rec [arg: ,(E-args proper arg*)]
+              [free: ,(map E free*)]
+          ,(E body))]
+      [(codes list body)
+       `(codes ,(map E list)
+          ,(E body))]
+      [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))]
+      [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))]
+      [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))]
+      [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))]
+      [(return x) `(return ,(E x))]
+      [(new-frame base-idx size body)
+       `(new-frame [base: ,base-idx]
+                   [size: ,size]
+          ,(E body))]
+      [(frame-var idx) 
+       (string->symbol (format "fv.~a" idx))]
+      [(cp-var idx) 
+       (string->symbol (format "cp.~a" idx))]
+      [(save-cp expr)
+       `(save-cp ,(E expr))]
+      [(eval-cp check body)
+       `(eval-cp ,check ,(E body))]
+      [(call-cp call-convention rp-convention base-idx arg-count live-mask)
+       `(call-cp [conv: ,call-convention]
+                 [rpconv: ,rp-convention]
+                 [base-idx: ,base-idx]
+                 [arg-count: ,arg-count]
+                 [live-mask: ,live-mask])]
+      [(foreign-label x) `(foreign-label ,x)]
+      [else (error 'unparse "invalid record ~s" x)]))
+  (E x))
+
+(define (optimize-direct-calls x)
+  (define who 'optimize-direct-calls)
+  (define (make-conses ls)
+    (cond
+      [(null? ls) (make-constant '())]
+      [else 
+       (make-primcall 'cons 
+         (list (car ls) (make-conses (cdr ls))))]))      
+  (define (properize lhs* rhs*)
+    (cond
+      [(null? lhs*) (error who "improper improper")]
+      [(null? (cdr lhs*)) 
+       (list (make-conses rhs*))]
+      [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))]))
+  (define (inline-case cls rand*)
+    (record-case cls
+      [(clambda-case fml* proper body)
+       (if proper
+           (and (fx= (length fml*) (length rand*))
+                (make-bind fml* rand* body))
+           (and (fx<= (length fml*) (length rand*))
+                (make-bind fml* (properize fml* rand*) body)))]))
+  (define (try-inline cls* rand* default)
+    (cond
+      [(null? cls*) default]
+      [(inline-case (car cls*) rand*)]
+      [else (try-inline (cdr cls*) rand* default)]))
+  (define (inline rator rand*)
+    (record-case rator
+      [(clambda cls*)
+       (try-inline cls* rand*
+           (make-funcall rator rand*))]
+      [else (make-funcall rator rand*)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (make-recbind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (inline (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+
+(define lambda-both 0)
+(define lambda-producer 0)
+(define lambda-consumer 0)
+(define lambda-none 0)
+(define branching-producer 0)
+
+
+(define (analyze-cwv x)
+  (define who 'analyze-cwv)
+  (define (lambda? x)
+    (record-case x
+      [(clambda) #t]
+      [else      #f]))
+  (define (branching-producer? x)
+    (define (bt? x)
+      (record-case x
+        [(bind lhs* rhs* body) (bt? body)]
+        [(recbind lhs* rhs* body) (bt? body)]
+        [(conditional test conseq altern) #t]
+        [(seq e0 e1) (bt? e1)]
+        [else #f]))
+    (define (branching-clause? x)
+      (record-case x 
+        [(clambda-case fml* proper body) 
+         (bt? body)]))
+    (record-case x
+      [(clambda cls*)
+       (ormap branching-clause? cls*)]
+      [else #f]))
+  (define (analyze producer consumer)
+    (cond
+      [(and (lambda? producer) (lambda? consumer))
+       (set! lambda-both (fxadd1 lambda-both))]
+      [(lambda? producer) 
+       (set! lambda-producer (fxadd1 lambda-producer))]
+      [(lambda? consumer)
+       (set! lambda-consumer (fxadd1 lambda-consumer))]
+      [else 
+       (set! lambda-none (fxadd1 lambda-none))])
+    (when (branching-producer? producer)
+      (set! branching-producer (fxadd1 branching-producer)))
+    (printf "both=~s p=~s c=~s none=~s branching-prod=~s\n"
+            lambda-both lambda-producer lambda-consumer lambda-none
+            branching-producer))
+  (define (E x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (for-each E rhs*) (E body)]
+      [(recbind lhs* rhs* body)
+       (for-each E rhs*) (E body)]
+      [(conditional test conseq altern)
+       (E test)
+       (E conseq)
+       (E altern)]
+      [(seq e0 e1) (E e0) (E e1)]
+      [(clambda cls*)
+       (for-each 
+         (lambda (x)
+           (record-case x
+             [(clambda-case fml* proper body) (E body)]))
+         cls*)]
+      [(primcall rator rand*) 
+       (for-each E rand*)
+       (when (and (eq? rator 'call-with-values) (fx= (length rand*) 2))
+         (analyze (car rand*) (cadr rand*)))]
+      [(funcall rator rand*)
+       (E rator) (for-each E rand*)
+       (when (and (record-case rator
+                    [(primref op) (eq? op 'call-with-values)]
+                    [else #f])
+                  (fx= (length rand*) 2))
+         (analyze (car rand*) (cadr rand*)))]
+      [(appcall rator rand*)
+       (E rator) (for-each E rand*)]
+      [(forcall rator rand*) 
+       (for-each E rand*)]
+      [(assign lhs rhs)
+       (E rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x))
+
+
+
+
+(define (optimize-letrec x)
+  (define who 'optimize-letrec)
+  (define (extend-hash lhs* h ref)
+    (for-each (lambda (lhs) (put-hash-table! h lhs #t)) lhs*)
+    (lambda (x)
+      (unless (get-hash-table h x #f)
+        (put-hash-table! h x #t)
+        (ref x))))
+  (define (E* x* ref comp)
+    (cond
+      [(null? x*) '()]
+      [else
+       (cons (E (car x*) ref comp)
+             (E* (cdr x*) ref comp))]))  
+  (define (do-rhs* i lhs* rhs* ref comp vref vcomp)
+    (cond
+      [(null? rhs*) '()]
+      [else
+       (let ([h (make-hash-table)])
+         (let ([ref
+                (lambda (x)
+                  (unless (get-hash-table h x #f)
+                    (put-hash-table! h x #t)
+                    (ref x)
+                    (when (memq x lhs*)
+                      (vector-set! vref i #t))))]
+               [comp
+                (lambda ()
+                  (vector-set! vcomp i #t)
+                  (comp))])
+           (cons (E (car rhs*) ref comp)
+                 (do-rhs* (fxadd1 i) lhs* (cdr rhs*) ref comp vref vcomp))))]))
+  (define (partition-rhs* i lhs* rhs* vref vcomp)
+    (cond
+      [(null? lhs*) (values '() '() '() '() '() '())]
+      [else
+       (let-values 
+         ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+           (partition-rhs* (fxadd1 i) (cdr lhs*) (cdr rhs*) vref vcomp)]
+          [(lhs rhs) (values (car lhs*) (car rhs*))])
+         (cond
+           [(var-assigned lhs) 
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [(clambda? rhs)
+            (values slhs* srhs* (cons lhs llhs*) (cons rhs lrhs*) clhs* crhs*)]
+           [(or (vector-ref vref i) (vector-ref vcomp i))
+            (values slhs* srhs* llhs* lrhs* (cons lhs clhs*) (cons rhs crhs*))]
+           [else
+            (values (cons lhs slhs*) (cons rhs srhs*) llhs* lrhs* clhs* crhs*)]
+           ))]))
+  (define (do-recbind lhs* rhs* body ref comp)
+    (let ([h (make-hash-table)]
+          [vref (make-vector (length lhs*) #f)]
+          [vcomp (make-vector (length lhs*) #f)])
+      (let* ([ref (extend-hash lhs* h ref)]
+             [body (E body ref comp)])
+        (let ([rhs* (do-rhs* 0 lhs* rhs* ref comp vref vcomp)])
+          (let-values ([(slhs* srhs* llhs* lrhs* clhs* crhs*)
+                        (partition-rhs* 0 lhs* rhs* vref vcomp)])
+            (let ([v* (map (lambda (x) (make-primcall 'void '())) clhs*)]
+                  [t* (map (lambda (x) (unique-var 'tmp)) clhs*)])
+              (make-bind slhs* srhs*
+                (make-bind clhs* v*
+                  (make-fix llhs* lrhs*
+                    (make-bind t* crhs*
+                      (build-assign* clhs* t* body)))))))))))
+  (define (build-assign* lhs* rhs* body)
+    (cond
+      [(null? lhs*)  body]
+      [else
+       (make-seq
+         (make-assign (car lhs*) (car rhs*))
+         (build-assign* (cdr lhs*) (cdr rhs*) body))]))
+  (define (E x ref comp)
+    (record-case x
+      [(constant) x]
+      [(var) (ref x) x]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (ref lhs)
+       (make-assign lhs (E rhs ref comp))]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let ([rhs* (E* rhs* ref comp)])
+         (let ([h (make-hash-table)])
+           (let ([body (E body (extend-hash lhs* h ref) comp)])
+             (make-bind lhs* rhs* body))))]
+      [(recbind lhs* rhs* body)
+       (if (null? lhs*)
+           (E body ref comp)
+           (do-recbind lhs* rhs* body ref comp))]
+      [(conditional e0 e1 e2)
+       (make-conditional (E e0 ref comp) (E e1 ref comp) (E e2 ref comp))]
+      [(seq e0 e1) (make-seq (E e0 ref comp) (E e1 ref comp))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (let ([h (make-hash-table)])
+                     (let ([body (E body (extend-hash fml* h ref) void)])
+                       (make-clambda-case fml* proper body)))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (when (memq rator '(call/cc call/cf))
+         (comp))
+       (make-primcall rator (E* rand* ref comp))]
+      [(funcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-funcall rator rand*))]
+      [(appcall rator rand*)
+       (let ([rator (E rator ref comp)] [rand* (E* rand* ref comp)])
+         (record-case rator
+           [(primref op)
+            (when (memq op '(call/cc call/cf))
+              (comp))]
+           [else
+            (comp)])
+         (make-appcall rator rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (E* rand* ref comp))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (E x (lambda (x) (error who "free var ~s found" x))
+       void))
+
+
+(define (remove-letrec x)
+  (define who 'remove-letrec)
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(recbind lhs* rhs* body)
+       (let ([t* (map (lambda (lhs) (unique-var 'tmp)) lhs*)]
+             [v* (map (lambda (lhs) (make-primcall 'void '())) lhs*)])
+         (make-bind lhs* v*
+           (make-bind t* (map Expr rhs*)
+             (let f ([lhs* lhs*] [t* t*])
+               (cond
+                 [(null? lhs*) (Expr body)]
+                 [else
+                  (make-seq
+                    (make-assign (car lhs*) (car t*))
+                    (f (cdr lhs*) (cdr t*)))])))))]
+      ;[(fix lhs* rhs* body)
+      ; (Expr (make-recbind lhs* rhs* body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test)
+         (Expr conseq)
+         (Expr altern))]
+      [(seq e0 e1) 
+       (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (make-clambda
+         (map (lambda (x)
+                (record-case x
+                  [(clambda-case fml* proper body)
+                   (make-clambda-case fml* proper (Expr body))]))
+              cls*))]
+      [(primcall rator rand*) 
+       (make-primcall rator (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(forcall rator rand*) 
+       (make-forcall rator (map Expr rand*))]
+      [(assign lhs rhs)
+       (make-assign lhs (Expr rhs))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (uncover-assigned x)
+  (define who 'uncover-assigned)
+  (define (Expr* x*)
+    (for-each Expr x*))
+  (define (Expr x)
+    (record-case x
+      [(constant) (void)]
+      [(var) (void)]
+      [(primref) (void)]
+      [(bind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(recbind lhs* rhs* body)
+       (begin (Expr body) (Expr* rhs*))]
+      [(fix lhs* rhs* body)
+       (Expr* rhs*) 
+       (Expr body)
+       (when (ormap var-assigned lhs*)
+         (error 'uncover-assigned "a fix lhs is assigned"))]
+      [(conditional test conseq altern)
+       (begin (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (begin (Expr e0) (Expr e1))]
+      [(clambda cls*)
+       (for-each
+         (lambda (cls)
+           (Expr (clambda-case-body cls)))
+         cls*)]
+      [(primcall rator rand*) (Expr* rand*)]
+      [(funcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(appcall rator rand*)
+       (begin (Expr rator) (Expr* rand*))]
+      [(forcall rator rand*) (Expr* rand*)]
+      [(assign lhs rhs)
+       (set-var-assigned! lhs #t)
+       (Expr rhs)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+
+
+
+(define (rewrite-assignments x)
+  (define who 'rewrite-assignments)
+  (define (fix-lhs* lhs*)
+    (cond
+      [(null? lhs*) (values '() '() '())]
+      [else
+       (let ([x (car lhs*)])
+         (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* (cdr lhs*))])
+           (cond
+             [(var-assigned x)
+              (let ([t (unique-var 'assignment-tmp)])
+                (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))]
+             [else
+              (values (cons x lhs*) a-lhs* a-rhs*)])))]))
+  (define (bind-assigned lhs* rhs* body)
+    (cond
+      [(null? lhs*) body]
+      [else
+       (make-bind lhs*
+         (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*)
+         body)]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(var-assigned x) 
+          (make-primcall '$vector-ref (list x (make-constant 0)))]
+         [else x])]
+      [(primref) x]
+      [(bind lhs* rhs* body)
+       (let-values ([(lhs* a-lhs* a-rhs*) (fix-lhs* lhs*)]) 
+         (make-bind lhs* (map Expr rhs*) 
+           (bind-assigned a-lhs* a-rhs* (Expr body))))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(clambda cls*) 
+       (make-clambda
+         (map (lambda (cls)
+                (record-case cls
+                  [(clambda-case fml* proper body)
+                   (let-values ([(fml* a-lhs* a-rhs*) (fix-lhs* fml*)])
+                     (make-clambda-case fml* proper 
+                       (bind-assigned a-lhs* a-rhs* (Expr body))))]))
+              cls*))]
+      [(primcall op rand*)
+       (make-primcall op (map Expr rand*))]
+      [(forcall op rand*)
+       (make-forcall op (map Expr rand*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall rator rand*)
+       (make-appcall (Expr rator) (map Expr rand*))]
+      [(assign lhs rhs)
+       (unless (var-assigned lhs)
+         (error 'rewrite-assignments "not assigned ~s in ~s" lhs x))
+       (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (Expr x))
+ 
+
+(define (remove-assignments x)
+    (uncover-assigned x)
+    (rewrite-assignments x))
+  
+
+
+
+
+(define (convert-closures prog)
+  (define who 'convert-closures)
+  (define (Expr* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (Expr (car x*))]
+                    [(d d-free) (Expr* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+   (define (do-clambda* x*)
+    (cond
+      [(null? x*) (values '() '())]
+      [else
+       (let-values ([(a a-free) (do-clambda (car x*))]
+                    [(d d-free) (do-clambda* (cdr x*))])
+         (values (cons a d) (union a-free d-free)))]))
+  (define (do-clambda x)
+    (record-case x 
+      [(clambda cls*)
+       (let-values ([(cls* free) 
+                     (let f ([cls* cls*])
+                       (cond
+                         [(null? cls*) (values '() '())]
+                         [else
+                          (record-case (car cls*)
+                            [(clambda-case fml* proper body)
+                             (let-values ([(body body-free) (Expr body)]
+                                          [(cls* cls*-free) (f (cdr cls*))])
+                               (values
+                                 (cons (make-clambda-case fml* proper body)
+                                       cls*)
+                                 (union (difference body-free fml*) 
+                                        cls*-free)))])]))])
+          (values (make-closure (make-clambda-code (gensym) cls* free) free)
+                  free))]))
+  (define (Expr ex)
+    (record-case ex
+      [(constant) (values ex '())]
+      [(var) (values ex (singleton ex))]
+      [(primref) (values ex '())]
+      [(bind lhs* rhs* body)
+       (let-values ([(rhs* rhs-free) (Expr* rhs*)] 
+                    [(body body-free) (Expr body)])
+          (values (make-bind lhs* rhs* body)
+                  (union rhs-free (difference body-free lhs*))))]
+      [(fix lhs* rhs* body)
+       (let-values ([(rhs* rfree) (do-clambda* rhs*)]
+                    [(body bfree) (Expr body)])
+          (values (make-fix lhs* rhs* body)
+                  (difference (union bfree rfree) lhs*)))]
+      [(conditional test conseq altern)
+       (let-values ([(test test-free) (Expr test)]
+                    [(conseq conseq-free) (Expr conseq)]
+                    [(altern altern-free) (Expr altern)])
+         (values (make-conditional test conseq altern)
+                 (union test-free (union conseq-free altern-free))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 e0-free) (Expr e0)]
+                    [(e1 e1-free) (Expr e1)])
+         (values (make-seq e0 e1) (union e0-free e1-free)))]
+      [(clambda)
+       (do-clambda ex)]
+      [(primcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-primcall op rand*)  rand*-free))]
+      [(forcall op rand*)
+       (let-values ([(rand* rand*-free) (Expr* rand*)])
+         (values (make-forcall op rand*)  rand*-free))]
+      [(funcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-funcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [(appcall rator rand*)
+       (let-values ([(rator rat-free) (Expr rator)]
+                    [(rand* rand*-free) (Expr* rand*)])
+         (values (make-appcall rator rand*) 
+                 (union rat-free rand*-free)))]
+      [else (error who "invalid expression ~s" (unparse ex))]))
+  (let-values ([(prog free) (Expr prog)])
+    (unless (null? free) 
+      (error 'convert-closures "free vars ~s encountered in ~a"
+          free (unparse prog)))
+   prog))
+
+
+(define (lift-codes x)
+  (define who 'lift-codes)
+  (define all-codes '())
+  (define (do-code x)
+    (record-case x
+      [(clambda-code label cls* free) 
+       (let ([cls* (map 
+                     (lambda (x)
+                       (record-case x
+                         [(clambda-case fml* proper body)
+                          (make-clambda-case fml* proper (E body))]))
+                     cls*)])
+         (let ([g (make-code-loc label)])
+           (set! all-codes
+             (cons (make-clambda-code label cls* free) all-codes))
+           g))]))
+  (define (E x)
+    (record-case x
+      [(constant) x]
+      [(var)      x]
+      [(primref)  x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map E rhs*) (E body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map E rhs*) (E body))]
+      [(conditional test conseq altern)
+       (make-conditional (E test) (E conseq) (E altern))]
+      [(seq e0 e1)           (make-seq (E e0) (E e1))]
+      [(closure c free)      (make-closure (do-code c) free)]
+      [(primcall op rand*)   (make-primcall op (map E rand*))]
+      [(forcall op rand*)    (make-forcall op (map E rand*))]
+      [(funcall rator rand*) (make-funcall (E rator) (map E rand*))]
+      [(appcall rator rand*) (make-appcall (E rator) (map E rand*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (let ([x (E x)])
+    (make-codes all-codes x)))
+
+
+
+            
+(define (syntactically-valid? op rand*)
+  (define (valid-arg-count? op rand*)
+    (let ([n (open-coded-primitive-args op)] [m (length rand*)])
+      (cond
+        [(eq? n 'any) #t]
+        [(eq? n 'positive) (fx> m 1)]
+        [(eq? n 'no-code) 
+         (error 'syntactically-valid
+           "should not primcall non codable prim ~s" op)]
+        [(fixnum? n) 
+         (cond
+          [(fx= n m) #t]
+          [else
+           (error 'compile 
+             "Possible incorrect number of args in ~s"
+              (cons op (map unparse rand*)))
+           #f])]
+        [else (error 'do-primcall "BUG: what ~s" n)])))
+  (define (check op pred?)
+    (lambda (arg)
+      (record-case arg
+        [(constant c)
+         (cond
+           [(pred? c) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [(primref) 
+         (cond
+           [(pred? (lambda (x) x)) #t]
+           [else
+            (error 'compile "Possible argument error to primitive ~s" op)
+            #f])]
+        [else #t])))
+  (define (nonnegative-fixnum? n)
+    (and (fixnum? n) (fx>= n 0)))
+  (define (byte? n)
+    (and (fixnum? n) (fx<= 0 n) (fx<= n 127)))
+  (define (valid-arg-types? op rand*)
+    (case op
+      [(fixnum? immediate? boolean? char? vector? string? procedure?
+        null? pair? not cons eq? vector symbol? error eof-object eof-object? 
+        void $unbound-object? $code? $forward-ptr? bwp-object?
+        pointer-value top-level-value car cdr list* list $record)
+       '#t]
+      [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* 
+        $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) 
+       (andmap (check op fixnum?) rand*)]
+      [($fixnum->char) 
+       (andmap (check op byte?) rand*)]
+      [($char->fixnum $char= $char< $char<= $char> $char>= $string)
+       (andmap (check op char?) rand*)]
+      [($make-vector $make-string)
+       (andmap (check op nonnegative-fixnum?) rand*)]
+      [($car $cdr) 
+       (andmap (check op pair?) rand*)]
+      [($vector-length) 
+       (andmap (check op vector?) rand*)]
+      [($string-length) 
+       (andmap (check op string?) rand*)]
+      [($set-car! $set-cdr!)
+       ((check op pair?) (car rand*))]
+      [($vector-ref $vector-set!)
+       (and ((check op vector?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($string-ref $string-set!
+        $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2)
+       (and ((check op string?) (car rand*))
+            ((check op nonnegative-fixnum?) (cadr rand*)))]
+      [($symbol-string $symbol-unique-string)
+       (andmap (check op symbol?) rand*)]
+      [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol
+        $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist!
+        $set-symbol-system-value! $set-symbol-system-value!
+        $set-symbol-unique-string!
+        $set-symbol-string!
+        $seal-frame-and-call  $frame->continuation $code->closure
+        $code-size $code-reloc-vector $code-freevars 
+        $code-ref $code-set!
+        $make-record $record? $record/rtd? $record-rtd $record-ref $record-set!
+        primitive-set! primitive-ref
+        $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next
+        $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!)
+       #t]
+      [else (error 'valid-arg-types? "unhandled op ~s" op)]))
+  (and (valid-arg-count? op rand*)
+       (or (null? rand*)
+           (valid-arg-types? op rand*))))
+
+
+;;; the output of simplify-operands differs from the input in that the 
+;;; operands to primcalls are all simple (variables, primrefs, or constants).
+;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to
+;;; primcalls.  
+
+
+(define uninlined '())
+(define (mark-uninlined x)
+  (cond
+    [(assq x uninlined) =>
+     (lambda (p) (set-cdr! p (fxadd1 (cdr p))))]
+    [else (set! uninlined (cons (cons x 1) uninlined))]))
+
+(module ()
+  (primitive-set! 'uninlined-stats 
+    (lambda () 
+      (let f ([ls uninlined] [ac '()])
+        (cond
+          [(null? ls) ac]
+          [(fx> (cdar ls) 15)
+           (f (cdr ls) (cons (car ls) ac))]
+          [else (f (cdr ls) ac)])))))
+
+(define (introduce-primcalls x)
+  (define who 'introduce-primcalls)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (Expr (car arg*))
+         ;     (begin
+         ;       (warning 'compile "possible incorrect number of values")
+         ;       (make-funcall (make-primref 'values) (map Expr arg*))))]
+         [else 
+          (make-primcall op (map Expr arg*))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator) 
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Expr (make-primcall (primref-name rator) rand*))]
+         [else
+          (when (primref? rator)
+            (mark-uninlined (primref-name rator)))
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(constant) (make-return x)]
+      [(var) (make-return x)]
+      [(primref) (make-return x)]
+      [(closure) (make-return x)]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(primcall op arg*)
+       (case op
+         ;[(values) 
+         ; (if (fx= (length arg*) 1)
+         ;     (make-return (Expr (car arg*)))
+         ;     (make-return* (map Expr arg*)))]
+         [else
+          (make-return (make-primcall op (map Expr arg*)))])]
+      [(forcall op arg*)
+       (make-return (make-forcall op (map Expr arg*)))]
+      [(funcall rator rand*)
+       (cond
+         [(and (primref? rator)
+               (open-codeable? (primref-name rator))
+               (syntactically-valid? (primref-name rator) rand*))
+          (Tail (make-primcall (primref-name rator) rand*))]
+         [else
+          (make-funcall (Expr rator) (map Expr rand*))])]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free) 
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (simplify-operands x)
+  (define who 'simplify-operands)
+  (define (simple? x) 
+    (or (constant? x) (var? x) (primref? x)))
+  (define (simplify arg lhs* rhs* k)
+    (if (simple? arg)
+        (k arg lhs* rhs*)
+        (let ([v (unique-var 'tmp)])
+          (k v (cons v lhs*) (cons (Expr arg) rhs*)))))
+  (define (simplify* arg* lhs* rhs* k)
+    (cond
+      [(null? arg*) (k '() lhs* rhs*)]
+      [else 
+       (simplify (car arg*) lhs* rhs*
+         (lambda (a lhs* rhs*)
+           (simplify* (cdr arg*) lhs* rhs*
+             (lambda (d lhs* rhs*)
+               (k (cons a d) lhs* rhs*)))))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) x]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (cond
+         [(memq op '(not car cdr))
+          (make-primcall op (map Expr arg*))]
+         [else
+          (simplify* arg* '() '()
+            (lambda (arg* lhs* rhs*)
+              (make-bind^ lhs* rhs* 
+                (make-primcall op arg*))))])]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* (map Expr rhs*) (Tail body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L clauses free)
+       (make-clambda-code L (map CaseExpr clauses) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+(define (insert-stack-overflow-checks x)
+  (define who 'insert-stack-overflow-checks)
+  (define (insert-check body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$fp-overflow '())
+        (make-funcall (make-primref 'do-stack-overflow) '())
+        (make-primcall 'void '()))
+      body))
+  (define (Expr x)
+    (record-case x
+      [(constant) #f]
+      [(var) #f]
+      [(primref) #f]
+      [(closure code free*) #f]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Expr body))]
+      [(fix lhs* rhs* body) (Expr body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (or (Expr e0) (Expr e1))]
+      [(primcall op arg*) (ormap Expr arg*)]
+      [(forcall op arg*)  (ormap Expr arg*)]
+      [(funcall rator arg*) #t] 
+      [(appcall rator arg*)    #t]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (Expr v)]
+      [(bind lhs* rhs* body)
+       (or (ormap Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body) (Tail body)]
+      [(conditional test conseq altern)
+       (or (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (or (Expr e0) (Tail e1))]
+      [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] 
+      [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (if (Tail body)
+           (make-clambda-case fml* proper (insert-check body))
+           x)]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list)
+                   (if (Tail body)
+                       (insert-check body)
+                       body))]))
+  (CodesExpr x))
+
+
+(define (insert-allocation-checks x)
+  (define who 'insert-allocation-checks)
+  (define (check-bytes n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-bytes
+          (list (make-constant n) var))
+        (make-forcall "ik_collect" ;(make-primref 'do-overflow) 
+                      (list 
+                        (make-primcall '$fx+ 
+                          (list (make-constant (fx+ n 4096)) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-words n var body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-words
+          (list (make-constant n) var))
+        (make-forcall "ik_collect" ; (make-primref 'do-overflow-words)
+                      (list
+                        (make-primcall '$fx+ 
+                          (list (make-constant (fx+ n 4096)) var))))
+        (make-primcall 'void '()))
+      body))
+  (define (check-const n body)
+    (make-seq
+      (make-conditional 
+        (make-primcall '$ap-check-const
+          (list (make-constant n)))
+        (make-forcall "ik_collect" ;(make-primref 'do-overflow) 
+                      (list (make-constant (fx+ n 4096))))
+        (make-primcall 'void '()))
+      body))
+  (define (closure-size x)
+    (record-case x 
+      [(closure code free*)
+       (align (fx+ disp-closure-data (fx* (length free*) wordsize)))]
+      [else (error 'closure-size "~s is not a closure" x)]))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (Expr x)
+    (record-case x
+      [(constant) x]
+      [(var) x]
+      [(primref) x]
+      [(closure) 
+       (check-const (closure-size x) x)]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Expr body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Expr body))))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Expr body))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Expr conseq) (Expr altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Expr e1))]
+      [(primcall op arg*)
+       (let ([x (make-primcall op (map Expr arg*))])
+         (case op
+           [(cons) (check-const pair-size x)]
+           [($make-symbol) (check-const symbol-size x)]
+           [($make-tcbucket) (check-const tcbucket-size x)]
+           [($frame->continuation $code->closure) 
+            (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)]
+           [($make-string) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ i (fx+ disp-string-data 1)) x)]
+              [else
+               (check-bytes (fxadd1 disp-string-data) (car arg*) x)])]
+           [($string)
+            (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)]
+           [($make-vector) 
+            (record-case (car arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-vector-data) x)]
+              [else
+               (check-words (fxadd1 disp-vector-data) (car arg*) x)])]
+           [($make-record) 
+            (record-case (cadr arg*)
+              [(constant i)
+               (check-const (fx+ (fx* i wordsize) disp-record-data) x)]
+              [else
+               (check-words (fxadd1 disp-record-data) (cadr arg*) x)])]
+           [(list*)
+            (check-const (fx* (fxsub1 (length arg*)) pair-size) x)]
+           [(list)
+            (check-const (fx* (length arg*) pair-size) x)]
+           [(vector $record)
+            (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)]
+           [else x]))]
+      [(forcall op arg*)
+       (make-forcall op (map Expr arg*))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Tail x)
+    (record-case x
+      [(return v) (make-return (Expr v))]
+      [(bind lhs* rhs* body)
+       (make-bind lhs* (map Expr rhs*) (Tail body))]
+      [(fix lhs* rhs* body)
+       (if (null? lhs*)
+           (Tail body)
+           (check-const (sum 0 (map closure-size rhs*))
+             (make-fix lhs* rhs* 
+               (Tail body))))]
+      [(conditional test conseq altern)
+       (make-conditional (Expr test) (Tail conseq) (Tail altern))]
+      [(seq e0 e1) (make-seq (Expr e0) (Tail e1))]
+      [(funcall rator rand*)
+       (make-funcall (Expr rator) (map Expr rand*))]
+      [(appcall op arg*)
+       (make-appcall (Expr op) (map Expr arg*))]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (CaseExpr x)
+    (record-case x 
+      [(clambda-case fml* proper body)
+       (make-clambda-case fml* proper (Tail body))]))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) (Tail body))]))
+  (CodesExpr x))
+
+
+              
+(define (remove-local-variables x)
+  (define who 'remove-local-variables)
+  (define (simple* x* r)
+    (map (lambda (x) 
+           (cond
+             [(assq x r) => cdr]
+             [else
+               (when (var? x) (error who "unbound var ~s" x))
+               x]))
+          x*))
+  (define (env->mask r sz)
+    (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)])
+      (for-each 
+        (lambda (idx) 
+           (let ([q (fxsra idx 3)]
+                 [r (fxlogand idx 7)])
+             (vector-set! s q 
+               (fxlogor (vector-ref s q) (fxsll 1 r)))))
+        r)
+      s))
+  (define (check? x)
+    (cond
+      [(primref? x) #t]  ;;;; PRIMREF CHECK
+      [else         #t]))
+  (define (do-new-frame op rand* si r call-convention rp-convention orig-live)
+    (make-new-frame (fxadd1 si) (fx+ (length rand*) 2)
+      (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live])
+        (cond
+          [(null? r*) 
+           (make-seq
+             (make-seq 
+               (make-save-cp (make-frame-var si))
+               (case call-convention
+                 [(normal apply)
+                  (make-eval-cp (check? op) (Expr op nsi r (cons si live)))]
+                 [(foreign)
+                  (make-eval-cp #f (make-foreign-label op))]
+                 [else (error who "invalid convention ~s" call-convention)]))
+             (make-call-cp call-convention 
+                rp-convention
+                (fxadd1 si)    ; frame size
+                (length rand*) ; argc
+                (env->mask (cons si orig-live) ; cp and everything before it
+                           (fxadd1 si))))] ; mask-size ~~ frame size
+          [else
+           (make-seq 
+             (make-assign (make-frame-var nsi)
+               (Expr (car r*) nsi r live))
+             (f (cdr r*) (fxadd1 nsi) (cons nsi live)))]))))
+  (define (nop) (make-primcall 'void '()))
+  (define (do-bind lhs* rhs* body si r live k)
+    (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live])
+      (cond
+        [(null? lhs*) (k body si nr live)]
+        [else
+         (let ([v (make-frame-var si)])
+           (make-seq
+             (make-assign v (Expr (car rhs*) si r live))
+             (f (cdr lhs*) (cdr rhs*) (fxadd1 si)
+                (cons (cons (car lhs*) v) nr)
+                (cons si live))))])))
+  (define (do-closure r)
+    (lambda (x)
+      (record-case x
+        [(closure code free*)
+         (make-closure code (simple* free* r))])))
+  (define (do-fix lhs* rhs* body si r live k)
+    (let f ([l* lhs*] [nlhs* '()] [si si] [r r] [live live])
+      (cond
+        [(null? l*) 
+         (make-fix (reverse nlhs*) 
+                   (map (do-closure r) rhs*)
+                   (k body si r live))]
+        [else
+         (let ([v (make-frame-var si)])
+           (f (cdr l*) (cons v nlhs*) (fxadd1 si) 
+              (cons (cons (car l*) v) r)
+              (cons si live)))])))
+  (define (do-tail-frame-old op rand* si r call-conv live)
+    (define (const? x)
+      (record-case x
+        [(constant) #t]
+        [(primref)  #t]
+        [else       #f]))
+    (define (evalrand* rand* i si r live)
+      (cond
+        [(null? rand*) 
+         (make-eval-cp (check? op) (Expr op si r live))]
+        [(const? (car rand*))
+         (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r live)]
+        [else
+         (let ([v (make-frame-var si)]
+               [rhs (Expr (car rand*) si r live)])
+           (cond
+             [(and (frame-var? rhs)
+                   (fx= (frame-var-idx rhs) i))
+              (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r (cons si live))]
+             [else
+              (make-seq
+                (make-assign v rhs)
+                (evalrand* (cdr rand*) (fx+ 1 i) (fx+ 1 si) r
+                           (cons si live)))]))]))
+    (define (moverand* rand* i si ac)
+      (cond
+        [(null? rand*) ac]
+        [(const? (car rand*))
+         (make-seq
+           (make-assign (make-frame-var i) (car rand*))
+           (moverand* (cdr rand*) (fxadd1 i) (fxadd1 si) ac))]
+        [else
+         (make-seq
+           (make-assign (make-frame-var i) (make-frame-var si))
+           (moverand* (cdr rand*) (fxadd1 i) (fxadd1 si) ac))]))
+    (make-seq
+      (evalrand* rand* 1 si r live)
+      (moverand* rand* 1 si
+        (make-tailcall-cp call-conv (length rand*))))) 
+  (define (do-tail-frame op rand* si r call-conv live)
+    (define (const? x)
+      (record-case x
+        [(constant) #t]
+        [(primref)  #t]
+        [else       #f]))
+    (define (evalrand* rand* i si r live ac)
+      (cond
+        [(null? rand*) 
+         (make-seq
+           (make-eval-cp (check? op) (Expr op si r live))
+           ac)]
+        [(const? (car rand*))
+         (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r live
+           (make-seq ac
+             (make-assign (make-frame-var i) (car rand*))))]
+        [else
+         (let ([vsi (make-frame-var si)]
+               [rhs (Expr (car rand*) si r live)])
+           (cond
+             [(and (frame-var? rhs)
+                   (fx= (frame-var-idx rhs) i))
+              (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r (cons si live) ac)]
+             [(fx= i si)
+              (make-seq 
+                (make-assign vsi rhs)
+                (evalrand* (cdr rand*) (fx+ i 1) (fx+ si 1) r
+                           (cons si live) ac))]
+             [else
+              (make-seq
+                (make-assign vsi rhs)
+                (evalrand* (cdr rand*) (fxadd1 i) (fxadd1 si) r (cons si live)
+                  (make-seq ac
+                    (make-assign (make-frame-var i) vsi))))]))]))
+    (make-seq
+      (evalrand* rand* 1 si r live (make-primcall 'void '()))
+      (make-tailcall-cp call-conv (length rand*))))
+  (define (Tail x si r live)
+    (record-case x
+      [(return v) (make-return (Expr v si r live))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Tail)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Tail)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Tail conseq si r live) 
+         (Tail altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))]
+      [(primcall op arg*)
+       (make-return 
+         (make-primcall op 
+           (map (lambda (x) (Expr x si r live)) arg*)))]
+                                  
+      [(funcall op rand*)
+       (do-tail-frame op rand* si r 'normal live)]
+      [(appcall op rand*)
+       (do-tail-frame op rand* si r 'apply live)]
+;;;      [(funcall op rand*)
+;;;       (do-new-frame op rand* si r 'normal 'tail live)]
+;;;      [(appcall op rand*)
+;;;       (do-new-frame op rand* si r 'apply 'tail live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (Effect x si r live)
+    (record-case x
+      [(constant) (nop)]
+      [(var) (nop)] 
+      [(primref) (nop)]
+      [(closure code free*) (nop)]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Effect)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Effect)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Effect conseq si r live) 
+         (Effect altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op 
+         (map (lambda (x) (Expr x si r live)) arg*))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'effect live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'effect live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'effect live)]
+      [else (error who "invalid effect expression ~s" (unparse x))]))
+  (define (Expr x si r live)
+    (record-case x
+      [(constant) x]
+      [(var) 
+       (cond
+         [(assq x r) => cdr]
+         [else (error who "unbound var ~s" x)])]
+      [(primref) x]
+      [(closure code free*) 
+       (make-closure code (simple* free* r))]
+      [(bind lhs* rhs* body)
+       (do-bind lhs* rhs* body si r live Expr)]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* body si r live Expr)]
+      [(conditional test conseq altern)
+       (make-conditional 
+         (Expr test si r live)
+         (Expr conseq si r live) 
+         (Expr altern si r live))]
+      [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))]
+      [(primcall op arg*)
+       (make-primcall op 
+         (map (lambda (x) (Expr x si r live)) arg*))]
+      [(forcall op rand*)
+       (do-new-frame op rand* si r 'foreign 'value live)]
+      [(funcall op rand*)
+       (do-new-frame op rand* si r 'normal 'value live)]
+      [(appcall op rand*)
+       (do-new-frame op rand* si r 'apply 'value live)]
+      [else (error who "invalid expression ~s" (unparse x))]))
+  (define (bind-fml* fml* r)
+    (let f ([si 1] [fml* fml*])
+      (cond
+        [(null? fml*) (values '() si r '())]
+        [else
+          (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))])
+            (let ([v (make-frame-var si)])
+              (values (cons v nfml*)
+                      nsi
+                      (cons (cons (car fml*) v) r)
+                      (cons si live))))])))
+  (define (bind-free* free*)
+    (let f ([free* free*] [idx 0] [r '()])
+      (cond
+        [(null? free*) r]
+        [else
+          (f (cdr free*) (fxadd1 idx)
+             (cons (cons (car free*) (make-cp-var idx)) r))])))
+  (define CaseExpr 
+    (lambda (r)
+      (lambda (x)
+        (record-case x 
+          [(clambda-case fml* proper body)
+           (let-values ([(fml* si r live) (bind-fml* fml* r)])
+             (make-clambda-case fml* proper (Tail body si r live)))]))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (let ([r (bind-free* free)])
+         (make-clambda-code L (map (CaseExpr r) cases) free))]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 1 '() '()))]))
+  (CodesExpr x))
+
+
+
+(define checks-elim-count 0)
+(define (optimize-ap-check x)
+  (define who 'optimize-ap-check)
+  (define (min x y)
+    (if (fx< x y) x y))
+  (define (Tail x f)
+    (record-case x
+      [(return v)
+       (let-values ([(v f) (NonTail v f)])
+         (make-return v))]
+      [(fix lhs* rhs* body)
+       (make-fix lhs* rhs* (Tail body f))]
+      [(conditional test conseq altern)
+       (let-values ([(test f) (NonTail test f)])
+         (make-conditional 
+           test
+           (Tail conseq f)
+           (Tail altern f)))]
+      [(seq e0 e1) 
+       (let-values ([(e0 f) (NonTail e0 f)])
+         (make-seq e0 (Tail e1 f)))]
+      [(tailcall-cp) x]
+      [else (error who "invalid tail expression ~s" (unparse x))]))
+  (define (do-primcall op arg* f)
+    (case op
+      [($ap-check-const)
+       (let ([n (constant-value (car arg*))])
+         (cond
+           [(fx< n f) 
+            ;(set! checks-elim-count (fxadd1 checks-elim-count))
+            ;(printf "~s checks eliminated\n" checks-elim-count)
+            (values (make-constant #f) (fx- f n))]
+           [(fx<= n 4096)
+            (values (make-primcall '$ap-check-const 
+                                   (list (make-constant 4096)))
+                    (fx- 4096 n))]
+           [else
+            (values (make-primcall '$ap-check-const 
+                                   (list (make-constant (fx+ n 4096))))
+                    4096)]))]
+      [($ap-check-bytes $ap-check-words)
+       (values (make-primcall op 
+                 (list (make-constant (fx+ (constant-value (car arg*)) 
+                                           4096))
+                       (cadr arg*)))
+               4096)]
+      [else (values (make-primcall op arg*) f)]))
+  (define (NonTail x f)
+    (record-case x
+      [(constant)         (values x f)]
+      [(frame-var)        (values x f)]
+      [(cp-var)           (values x f)]
+      [(save-cp)          (values x f)]
+      [(foreign-label)    (values x f)]
+      [(primref)          (values x f)]
+      [(closure)          (values x f)]
+      [(call-cp call-conv) 
+       (if (eq? call-conv 'foreign)
+           (values x f)
+           (values x 0))]
+      [(primcall op arg*) (do-primcall op arg* f)]
+      [(fix lhs* rhs* body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-fix lhs* rhs* body) f))]
+      [(conditional test conseq altern)
+       (let-values ([(test f) (NonTail test f)])
+         (if (constant? test)
+             (if (constant-value test)
+                 (NonTail conseq f)
+                 (NonTail altern f))
+             (let-values ([(conseq f0) (NonTail conseq f)]
+                          [(altern f1) (NonTail altern f)])
+               (values (make-conditional test conseq altern)
+                       (min f0 f1)))))]
+      [(seq e0 e1) 
+       (let-values ([(e0 f) (NonTail e0 f)])
+         (let-values ([(e1 f) (NonTail e1 f)])
+           (values (make-seq e0 e1) f)))]
+      [(assign lhs rhs)
+       (let-values ([(rhs f) (NonTail rhs f)])
+         (values (make-assign lhs rhs) f))]
+      [(eval-cp check body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-eval-cp check body) f))]
+      [(new-frame base-idx size body)
+       (let-values ([(body f) (NonTail body f)])
+         (values (make-new-frame base-idx size body) f))]
+      [else (error who "invalid nontail expression ~s" (unparse x))]))
+  (define CaseExpr 
+    (lambda (x)
+      (record-case x 
+        [(clambda-case fml* proper body)
+         (make-clambda-case fml* proper (Tail body 0))])))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (make-clambda-code L (map CaseExpr cases) free)]))
+  (define (CodesExpr x)
+    (record-case x 
+      [(codes list body)
+       (make-codes (map CodeExpr list) 
+                   (Tail body 0))]))
+  (CodesExpr x))
+
+(begin
+  (define fx-shift 2)
+  (define fx-mask #x03)
+  (define fx-tag 0)
+  (define bool-f #x2F)
+  (define bool-t #x3F)
+  (define bool-mask #xEF)
+  (define bool-tag #x2F)
+  (define bool-shift 4)
+  (define nil     #x4F)
+  (define eof     #x5F) ; double check
+  (define unbound #x6F) ; double check
+  (define void-object #x7F) ; double check
+  (define bwp-object  #x8F) ; double check
+  (define char-shift 8)
+  (define char-tag #x0F)
+  (define char-mask #xFF)
+  (define pair-mask 7)
+  (define pair-tag  1)
+  (define disp-car  0)
+  (define disp-cdr  4)
+  (define pair-size 8)
+  (define pagesize 4096)
+  (define pageshift 12)
+  (define wordsize  4)
+  (define wordshift 2)
+  
+  (define symbol-mask 7)
+  (define symbol-tag 2)
+  (define disp-symbol-string         0)
+  (define disp-symbol-unique-string  4)
+  (define disp-symbol-value          8)
+  (define disp-symbol-plist         12)
+  (define disp-symbol-system-value  16)
+  (define disp-symbol-system-plist  20)
+  (define symbol-size 24)
+  (define vector-tag 5)
+  (define vector-mask 7)
+  (define disp-vector-length 0)
+  (define disp-vector-data 4)
+  (define string-mask 7)
+  (define string-tag 6)
+  (define disp-string-length 0)
+  (define disp-string-data 4)
+  (define closure-mask 7)
+  (define closure-tag 3)
+  (define disp-closure-data 4)
+  (define disp-closure-code 0)
+  (define continuation-size       16)
+  (define continuation-tag      #x1F)
+  (define disp-continuation-top    4)
+  (define disp-continuation-size   8)
+  (define disp-continuation-next  12)
+  (define code-tag              #x2F)
+  (define disp-code-instrsize      4)
+  (define disp-code-relocsize      8)
+  (define disp-code-freevars      12)
+  (define disp-code-data          16)
+  (define disp-tcbucket-tconc 0)
+  (define disp-tcbucket-key   4)
+  (define disp-tcbucket-val   8)
+  (define disp-tcbucket-next 12)
+  (define tcbucket-size      16)
+  (define record-ptag  5)
+  (define record-pmask 7)
+  (define disp-record-rtd     0)
+  (define disp-record-data    4)
+  (define disp-frame-size -17)
+  (define disp-frame-offset -13)
+  (define disp-multivalue-rp -9)
+  (define object-alignment 8)
+  (define align-shift 3)
+  (define dirty-word -1))
+
+(define (align n)
+  (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift))
+
+(begin
+  (define (mem off val)
+    (cond
+      [(fixnum? off) (list 'disp (int off) val)]
+      [(register? off) (list 'disp off val)]
+      [else (error 'mem "invalid disp ~s" off)]))
+  (define (int x) (list 'int x))
+  (define (obj x) (list 'obj x))
+  (define (byte x) (list 'byte x))
+  (define (byte-vector x) (list 'byte-vector x))
+  (define (movzbl src targ) (list 'movzbl src targ))
+  (define (sall src targ) (list 'sall src targ))
+  (define (sarl src targ) (list 'sarl src targ))
+  (define (shrl src targ) (list 'shrl src targ))
+  (define (notl src) (list 'notl src))
+  (define (pushl src) (list 'pushl src))
+  (define (popl src) (list 'popl src))
+  (define (orl src targ) (list 'orl src targ))
+  (define (xorl src targ) (list 'xorl src targ))
+  (define (andl src targ) (list 'andl src targ))
+  (define (movl src targ) (list 'movl src targ))
+  (define (movb src targ) (list 'movb src targ))
+  (define (addl src targ) (list 'addl src targ))
+  (define (imull src targ) (list 'imull src targ))
+  (define (idivl src) (list 'idivl src))
+  (define (subl src targ) (list 'subl src targ))
+  (define (push src) (list 'push src))
+  (define (pop targ) (list 'pop targ))
+  (define (sete targ) (list 'sete targ))
+  (define (call targ) (list 'call targ))
+  (define (tail-indirect-cpr-call)
+    (jmp (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (indirect-cpr-call)
+    (call (mem (fx- disp-closure-code closure-tag) cpr)))
+  (define (negl targ) (list 'negl targ))
+  (define (label x) (list 'label x))
+  (define (label-address x) (list 'label-address x))
+  (define (ret) '(ret))
+  (define (cltd) '(cltd))
+  (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2))
+  (define (je label) (list 'je label))
+  (define (jne label) (list 'jne label))
+  (define (jle label) (list 'jle label))
+  (define (jge label) (list 'jge label))
+  (define (jg label) (list 'jg label))
+  (define (jl label) (list 'jl label))
+  (define (jb label) (list 'jb label))
+  (define (ja label) (list 'ja label))
+  (define (jmp label) (list 'jmp label))
+  (define edi '%edx) ; closure pointer
+  (define esi '%esi) ; pcb
+  (define ebp '%ebp) ; allocation pointer
+  (define esp '%esp) ; stack base pointer 
+  (define al '%al)
+  (define ah '%ah)
+  (define bh '%bh)
+  (define cl '%cl)
+  (define eax '%eax)
+  (define ebx '%ebx)
+  (define ecx '%ecx)
+  (define edx '%edx)
+  (define apr '%ebp)
+  (define fpr '%esp)
+  (define cpr '%edi)
+  (define pcr '%esi)
+  (define register? symbol?)
+  (define (argc-convention n)
+    (fx- 0 (fxsll n fx-shift))))
+
+
+(define pcb-ref
+  (lambda (x)
+    (case x
+      [(allocation-pointer) (mem  0 pcr)]
+      [(allocation-redline) (mem  4 pcr)]
+      [(frame-pointer)      (mem  8 pcr)]
+      [(frame-base)         (mem 12 pcr)]
+      [(frame-redline)      (mem 16 pcr)]
+      [(next-continuation)  (mem 20 pcr)]
+      [(system-stack)       (mem 24 pcr)]
+      [(dirty-vector)       (mem 28 pcr)]
+      [else (error 'pcb-ref "invalid arg ~s" x)])))
+
+(define (primref-loc op)
+  (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op))
+  (mem (fx- disp-symbol-system-value symbol-tag)
+        (obj op)))
+
+
+(define (generate-code x)
+  (define who 'generate-code)
+  (define (rp-label x)
+    (case x
+      [(value) (label-address SL_multiple_values_error_rp)]
+      [(effect) (label-address SL_multiple_values_ignore_rp)]
+      [else (error who "invalid rp-convention ~s" x)]))
+  (define unique-label
+    (lambda ()
+      (label (gensym))))
+  (define (constant-val x)
+    (cond
+      [(fixnum? x) (obj x)]
+      [(boolean? x) (int (if x bool-t bool-f))]
+      [(null? x) (int nil)]
+      [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))]
+      [(eq? x (void)) (int void-object)]
+      [else (obj x)]))
+  (define (cond-branch op Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl]))))
+    (unless (or Lt Lf)
+      (error 'cond-branch "no labels"))
+    (cond
+      [(not Lf) (cons (list op Lt) ac)]
+      [(not Lt) (cons (list (opposite op) Lf) ac)] 
+      [else (list* (list op Lt) (jmp Lf) ac)]))
+  (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac)
+    (cond
+      [(and Lt Lf)
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              (jmp Lt)
+              ac)]
+      [Lf
+       (list* (movl (Simple (car rand*)) eax)
+              (movl eax ebx)
+              (andl (int pri-mask) ebx)
+              (cmpl (int pri-tag) ebx)
+              (jne Lf)
+              (movl (mem (fx- 0 pri-tag) eax) ebx)
+              (if sec-mask
+                  (andl (int sec-mask) ebx)
+                  '(nop))
+              (cmpl (int sec-tag) ebx)
+              (jne Lf)
+              ac)]
+      [Lt
+       (let ([L_END (unique-label)])
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int pri-mask) ebx)
+                (cmpl (int pri-tag) ebx)
+                (jne L_END)
+                (movl (mem (fx- 0 pri-tag) eax) ebx)
+                (if sec-mask
+                    (andl (int sec-mask) ebx)
+                    '(nop))
+                (cmpl (int sec-tag) ebx)
+                (je Lt)
+                L_END
+                ac))]
+      [else ac]))
+  (define (type-pred mask tag rand* Lt Lf ac)
+    (cond
+      [mask
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (andl (int mask) eax)
+         (cmpl (int tag) eax)
+         (cond-branch 'je Lt Lf ac))]
+      [else 
+       (let ([v (Simple (car rand*))])
+         (cond
+           [(memq (car v) '(mem register)) 
+            (list*
+              (cmpl (int tag) (Simple (car rand*)))
+              (cond-branch 'je Lt Lf ac))]
+           [else
+            (list*
+              (movl (Simple (car rand*)) eax)
+              (cmpl (int tag) eax)
+              (cond-branch 'je Lt Lf ac))]))])) 
+  (define (compare-and-branch op rand* Lt Lf ac)
+    (define (opposite x)
+      (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle]))))
+    (cond
+      [(and (constant? (car rand*)) (constant? (cadr rand*)))
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]
+      [(constant? (cadr rand*))
+       (list* 
+         (cmpl (Simple (cadr rand*)) (Simple (car rand*)))
+         (cond-branch op Lt Lf ac))]
+      [(constant? (car rand*))
+       (list*
+         (cmpl (Simple (car rand*)) (Simple (cadr rand*)))
+         (cond-branch (opposite op) Lt Lf ac))]
+      [else
+       (list* 
+         (movl (Simple (car rand*)) eax)
+         (cmpl (Simple (cadr rand*)) eax)
+         (cond-branch op Lt Lf ac))]))
+  (define (do-pred-prim op rand* Lt Lf ac)
+    (case op
+     [(fixnum?)    (type-pred fx-mask fx-tag rand* Lt Lf ac)]
+     [(pair?)      (type-pred pair-mask pair-tag rand* Lt Lf ac)]
+     [(char?)      (type-pred char-mask char-tag rand* Lt Lf ac)]
+     [(string?)    (type-pred string-mask string-tag rand* Lt Lf ac)]
+     [(symbol?)    (type-pred symbol-mask symbol-tag rand* Lt Lf ac)]
+     [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)]
+     [(boolean?)   (type-pred bool-mask bool-tag rand* Lt Lf ac)]
+     [(null?)      (type-pred #f nil rand* Lt Lf ac)]
+     [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)]
+     [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)]
+     [(not)        (Pred (car rand*) Lf Lt ac)]
+     ;[(not)        (type-pred #f bool-f rand* Lt Lf ac)]
+     [(eof-object?) (type-pred #f eof rand* Lt Lf ac)]
+     [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)]
+     [($code?) 
+      (indirect-type-pred vector-mask vector-tag #f code-tag 
+         rand* Lt Lf ac)]
+     [($fxzero?)   (type-pred #f 0 rand* Lt Lf ac)]
+     [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)]
+     [($fx< $char<)     (compare-and-branch 'jl rand* Lt Lf ac)]
+     [($fx<= $char<=)   (compare-and-branch 'jle rand* Lt Lf ac)]
+     [($fx> $char>)     (compare-and-branch 'jg rand* Lt Lf ac)]
+     [($fx>= $char>=)   (compare-and-branch 'jge rand* Lt Lf ac)]
+     [(vector?) 
+      (indirect-type-pred vector-mask vector-tag fx-mask fx-tag 
+         rand* Lt Lf ac)]
+     [($record?) 
+      (indirect-type-pred record-pmask record-ptag record-pmask record-ptag
+         rand* Lt Lf ac)]
+     [($record/rtd?)
+      (cond
+        [Lf
+         (list* (movl (Simple (car rand*)) eax)
+                (movl eax ebx)
+                (andl (int vector-mask) eax)
+                (cmpl (int vector-tag) eax)
+                (jne Lf)
+                (movl (Simple (cadr rand*)) eax)
+                (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                (jne Lf)
+                (if Lt
+                    (cons (jmp Lt) ac)
+                    ac))]
+        [Lt
+         (let ([Ljoin (unique-label)])
+           (list* (movl (Simple (car rand*)) eax)
+                  (movl eax ebx)
+                  (andl (int vector-mask) eax)
+                  (cmpl (int vector-tag) eax)
+                  (jne Ljoin)
+                  (movl (Simple (cadr rand*)) eax)
+                  (cmpl (mem (fx- disp-record-rtd vector-tag) ebx) eax)
+                  (je Lt)
+                  Ljoin
+                  ac))]
+        [else ac])]
+     [(immediate?)
+      (cond
+        [(and Lt Lf)
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             (jmp Lf)
+             ac)]
+        [Lt
+         (list* (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Lt)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (je Lt)
+             ac)]
+        [Lf
+         (let ([Ljoin (unique-label)])
+           (list* 
+             (movl (Simple (car rand*)) eax)
+             (movl eax ebx)
+             (andl (int fx-mask) ebx)
+             (cmpl (int 0) ebx)
+             (je Ljoin)
+             (andl (int 7) eax)
+             (cmpl (int 7) eax)
+             (jne Lf)
+             Ljoin
+             ac))]
+        [else ac])]
+     [($ap-check-words)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (pcb-ref 'allocation-redline) eax)
+                (subl (Simple (cadr rand*)) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-words")])]
+     [($ap-check-bytes)
+      (record-case (car rand*)
+        [(constant i)
+         (list* (movl (Simple (cadr rand*)) eax)
+                (negl eax)
+                (addl (pcb-ref 'allocation-redline) eax)
+                (subl (int i) eax)
+                (cmpl eax apr)
+                (cond-branch 'jge Lt Lf ac))]
+        [else (error who "ap-check-bytes")])]
+     [($ap-check-const) 
+      (record-case (car rand*)
+        [(constant i) 
+         (if (fx<= i pagesize)
+             (list* 
+               (cmpl (pcb-ref 'allocation-redline) apr)
+               (cond-branch 'jge Lt Lf ac))
+             (list* 
+               (movl (pcb-ref 'allocation-redline) eax)
+               (subl (int i) eax)
+               (cmpl eax apr)
+               (cond-branch 'jge Lt Lf ac)))]
+        [else (error who "ap-check-const")])]
+     [($fp-at-base) 
+      (list* 
+        (movl (pcb-ref 'frame-base) eax)
+        (subl (int wordsize) eax)
+        (cmpl eax fpr)
+        (cond-branch 'je Lt Lf ac))]
+     [($fp-overflow) 
+      (list* (cmpl (pcb-ref 'frame-redline) fpr)
+             (cond-branch 'jle Lt Lf ac))]
+     [($vector-ref top-level-value car cdr $record-ref) 
+      (do-value-prim op rand*
+        (do-simple-test eax Lt Lf ac))]
+     [(cons void $fxadd1 $fxsub1)
+      ;;; always true
+      (do-effect-prim op rand*
+        (cond
+          [(not Lt) ac]
+          [else (cons (jmp Lt) ac)]))]
+     [else 
+      (error 'pred-prim "HERE unhandled ~s" op)]))
+  (define (do-pred->value-prim op rand* ac)
+    (case op
+      [else
+       (let ([Lf (unique-label)] [Lj (unique-label)])
+         (do-pred-prim op rand* #f Lf
+           (list* (movl (constant-val #t) eax)
+                  (jmp Lj)
+                  Lf
+                  (movl (constant-val #f) eax)
+                  Lj
+                  ac)))]))
+  (define (indirect-ref arg* off ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (mem off eax) eax)
+      ac))
+  (define (do-value-prim op arg* ac)
+    (case op
+      [(eof-object) (cons (movl (int eof) eax) ac)]
+      [(void)       (cons (movl (int void-object) eax) ac)]
+      [($fxadd1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val 1) eax)
+              ac)]
+      [($fxsub1) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (constant-val -1) eax)
+              ac)]
+      [($fx+) 
+       (list* (movl (Simple (car arg*)) eax)
+              (addl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx-) 
+       (list* (movl (Simple (car arg*)) eax)
+              (subl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fx*)
+       (cond
+         [(constant? (car arg*))
+          (record-case (car arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (cadr arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [(constant? (cadr arg*))
+          (record-case (cadr arg*)
+            [(constant c)
+             (unless (fixnum? c)
+               (error who "invalid arg ~s to fx*" c))
+             (list* (movl (Simple (car arg*)) eax)
+                    (imull (int c) eax)
+                    ac)])]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int fx-shift) eax)
+                 (imull (Simple (cadr arg*)) eax)
+                 ac)])]
+      [($fxquotient)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ecx)
+              (cltd)
+              (idivl ecx)
+              (sall (int fx-shift) eax)
+              ac)]
+      [($fxmodulo)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax ecx)
+              (xorl ebx ecx)
+              (sarl (int (fxsub1 (fx* wordsize 8))) ecx)
+              (andl ebx ecx)
+              (cltd)
+              (idivl ebx)
+              (movl edx eax)
+              (addl ecx eax)
+              ac)]
+      [($fxlogor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogand) 
+       (list* (movl (Simple (car arg*)) eax)
+              (andl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxlogxor) 
+       (list* (movl (Simple (car arg*)) eax)
+              (xorl (Simple (cadr arg*)) eax)
+              ac)]
+      [($fxsra)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsra"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sarl (int (fx+ i fx-shift)) eax)
+                 (sall (int fx-shift) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sarl (int fx-shift) eax)
+                 (sarl cl eax)
+                 (sall (int fx-shift) eax)
+                 ac)])]
+      [($fxsll)
+       (record-case (cadr arg*)
+         [(constant i)
+          (unless (fixnum? i) (error who "invalid arg to fxsll"))
+          (list* (movl (Simple (car arg*)) eax)
+                 (sall (int i) eax)
+                 ac)]
+         [else
+          (list* (movl (Simple (car arg*)) eax)
+                 (movl (Simple (cadr arg*)) ecx)
+                 (sarl (int fx-shift) ecx)
+                 (sall cl eax)
+                 ac)])]
+      [($fixnum->char)  
+       (list* (movl (Simple (car arg*)) eax)
+              (sall (int (fx- char-shift fx-shift)) eax)
+              (orl (int char-tag) eax)
+              ac)]
+      [($char->fixnum) 
+       (list* (movl (Simple (car arg*)) eax)
+              (sarl (int (fx- char-shift fx-shift)) eax)
+              ac)]
+      [($fxlognot) 
+       (list* (movl (Simple (car arg*)) eax)
+              (orl (int fx-mask) eax)
+              (notl eax)
+              ac)]
+      [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)]
+      [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)]
+      [($vector-length) 
+       (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)]
+      [($string-length) 
+       (indirect-ref arg* (fx- disp-string-length string-tag) ac)]
+      [($symbol-string) 
+       (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)]
+      [($symbol-unique-string) 
+       (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)]
+      [($symbol-value) 
+       (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)]
+      [(primitive-ref) 
+       (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)]
+      [($tcbucket-key) 
+       (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($tcbucket-val) 
+       (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($tcbucket-next) 
+       (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [(pointer-value)
+       (list*
+         (movl (Simple (car arg*)) eax)
+         (sarl (int fx-shift) eax)
+         (sall (int fx-shift) eax)
+         ac)]
+      [($symbol-plist) 
+       (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)]
+      [($record-rtd) 
+       (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)]
+      [($constant-ref)
+       (list* (movl (Simple (car arg*)) eax) ac)]
+      [(car cdr)
+       (let ([x (car arg*)])
+         (NonTail x
+           (list* 
+             (movl eax ebx)
+             (andl (int pair-mask) eax)
+             (cmpl (int pair-tag) eax)
+             (if (eq? op 'car)
+                 (list* 
+                   (jne (label SL_car_error))
+                   (movl (mem (fx- disp-car pair-tag) ebx) eax)
+                   ac)
+                 (list* 
+                   (jne (label SL_cdr_error))
+                   (movl (mem (fx- disp-cdr pair-tag) ebx) eax)
+                   ac)))))]
+      [(top-level-value)
+       (let ([x (car arg*)])
+         (cond
+           [(constant? x)
+            (let ([v (constant-value x)])
+              (cond
+                [(symbol? v)
+                 (list* 
+                   (movl (mem (fx- disp-symbol-value symbol-tag) (obj v)) eax)
+                   (movl (obj v) ebx)
+                   (cmpl (int unbound) eax)
+                   (je (label SL_top_level_value_error))
+                   ac)]
+                [else
+                 (list* 
+                   (movl (obj v) ebx)
+                   (jmp (label SL_top_level_value_error))
+                   ac)]))]
+           [else
+            (NonTail x
+              (list* 
+                (movl eax ebx)
+                (andl (int symbol-mask) eax)
+                (cmpl (int symbol-tag) eax)
+                (jne (label SL_top_level_value_error))
+                (movl (mem (fx- disp-symbol-value symbol-tag) ebx) eax)
+                (cmpl (int unbound) eax)
+                (je (label SL_top_level_value_error))
+                ac))]))]
+      [($vector-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-vector-data vector-tag) ebx) eax)
+              ac)]
+      [($record-ref) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (mem (fx- disp-record-data record-ptag) ebx) eax)
+              ac)]
+      [($code-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int 0) eax)
+              (movb (mem (fx- disp-code-data vector-tag) ebx) ah)
+              (sarl (int (fx- 8 fx-shift)) eax)
+              ac)]
+      [($string-ref) 
+       (list* (movl (Simple (cadr arg*)) ebx)
+              (sarl (int fx-shift) ebx)
+              (addl (Simple (car arg*)) ebx)
+              (movl (int char-tag) eax)
+              (movb (mem (fx- disp-string-data string-tag) ebx) ah)
+              ac)]
+      [($make-string) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-string-length apr))
+              (movl apr eax)
+              (addl (int string-tag) eax)
+              (sarl (int fx-shift) ebx)
+              (addl ebx apr)
+              (movb (int 0) (mem disp-string-data apr))
+              (addl (int (fx+ disp-string-data object-alignment)) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-vector) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (movl ebx (mem disp-vector-length apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl ebx apr)
+              (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [($make-record) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-record-rtd apr))
+              (movl apr eax)
+              (addl (int record-ptag) eax)
+              (addl (Simple (cadr arg*)) apr)
+              (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr)
+              (sarl (int align-shift) apr)
+              (sall (int align-shift) apr)
+              ac)]
+      [(cons)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl eax (mem disp-car apr))
+              (movl apr eax)
+              (movl ebx (mem disp-cdr apr))
+              (addl (int pair-tag) eax)
+              (addl (int (align pair-size)) apr)
+              ac)]
+      [(list)
+       (cond
+         [(null? arg*) (NonTail (make-constant '()) ac)]
+         [else
+          (list*
+            (addl (int pair-tag) apr)
+            (movl apr eax)
+            (let f ([a (car arg*)] [d (cdr arg*)])
+              (list*
+                (movl (Simple a) ebx)
+                (movl ebx (mem (fx- disp-car pair-tag) apr))
+                (if (null? d)
+                    (list*
+                      (movl (int nil) (mem (fx- disp-cdr pair-tag) apr))
+                      (addl (int (fx- pair-size pair-tag)) apr)
+                      ac)
+                    (list*
+                      (addl (int pair-size) apr)
+                      (movl apr 
+                          (mem (fx- disp-cdr (fx+ pair-tag pair-size)) apr))
+                      (f (car d) (cdr d)))))))])]
+      [(list*)
+       (cond
+         [(fx= (length arg*) 1) (NonTail (car arg*) ac)]
+         [(fx= (length arg*) 2) (NonTail (make-primcall 'cons arg*) ac)]
+         [else
+          (list*
+            (addl (int pair-tag) apr)
+            (movl apr eax)
+            (let f ([a (car arg*)] [b (cadr arg*)] [d (cddr arg*)])
+              (list*
+                (movl (Simple a) ebx)
+                (movl ebx (mem (fx- disp-car pair-tag) apr))
+                (if (null? d)
+                    (list*
+                      (movl (Simple b) ebx)
+                      (movl ebx (mem (fx- disp-cdr pair-tag) apr))
+                      (addl (int (fx- pair-size pair-tag)) apr)
+                      ac)
+                    (list*
+                      (addl (int pair-size) apr)
+                      (movl apr 
+                          (mem (fx- disp-cdr (fx+ pair-tag pair-size)) apr))
+                      (f b (car d) (cdr d)))))))])]
+      [($make-symbol)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-symbol-string apr))
+              (movl (int 0) (mem disp-symbol-unique-string apr))
+              (movl (int unbound) (mem disp-symbol-value apr))
+              (movl (int nil) (mem disp-symbol-plist apr))
+              (movl (int unbound) (mem disp-symbol-system-value apr))
+              (movl (int nil) (mem disp-symbol-system-plist apr))
+              (movl apr eax)
+              (addl (int symbol-tag) eax)
+              (addl (int (align symbol-size)) apr)
+              ac)]
+      [($make-tcbucket)
+       (list* (movl (Simple (car arg*)) eax)
+              (movl eax (mem disp-tcbucket-tconc apr))
+              (movl (Simple (cadr arg*)) eax)
+              (movl eax (mem disp-tcbucket-key apr))
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-val apr))
+              (movl (Simple (cadddr arg*)) eax)
+              (movl eax (mem disp-tcbucket-next apr))
+              (movl apr eax)
+              (addl (int vector-tag) eax)
+              (addl (int (align tcbucket-size)) apr)
+              ac)] 
+      [($record) 
+       (let ([rtd (car arg*)]
+             [ac 
+              (let f ([arg* (cdr arg*)] [idx disp-record-data])
+                (cond
+                  [(null? arg*) 
+                   (list* (movl apr eax)
+                          (addl (int vector-tag) eax)
+                          (addl (int (align idx)) apr)
+                          ac)]
+                  [else 
+                   (list* (movl (Simple (car arg*)) eax)
+                          (movl eax (mem idx apr))
+                          (f (cdr arg*) (fx+ idx wordsize)))]))])
+         (cond
+           [(constant? rtd)
+            (list* (movl (Simple rtd) (mem 0 apr)) ac)]
+           [else
+            (list* (movl (Simple rtd) eax) (movl eax (mem 0 apr)) ac)]))]
+      [(vector) 
+       (let f ([arg* arg*] [idx disp-vector-data])
+         (cond
+           [(null? arg*) 
+            (list* (movl apr eax)
+                   (addl (int vector-tag) eax)
+                   (movl (int (fx- idx disp-vector-data))
+                         (mem disp-vector-length apr))
+                   (addl (int (align idx)) apr)
+                   ac)]
+           [else 
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem idx apr))
+                   (f (cdr arg*) (fx+ idx wordsize)))]))]
+     [($string)
+      (let f ([arg* arg*] [idx disp-string-data])
+        (cond
+          [(null? arg*) 
+           (list* (movb (int 0) (mem idx apr))
+                  (movl apr eax)
+                  (addl (int string-tag) eax)
+                  (movl (int (fx* (fx- idx disp-string-data) wordsize))
+                        (mem disp-string-length apr))
+                  (addl (int (align (fxadd1 idx))) apr)
+                  ac)]
+          [else
+           (record-case (car arg*)
+             [(constant c) 
+              (unless (char? c) (error who  "invalid arg to string ~s" x))
+              (list* (movb (int (char->integer c)) (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))]
+             [else
+              (list* (movl (Simple (car arg*)) ebx)
+                     (movb bh (mem idx apr))
+                     (f (cdr arg*) (fxadd1 idx)))])]))]
+     [($current-frame)
+      (list* (movl (pcb-ref 'next-continuation) eax)
+             ac)]
+     [($seal-frame-and-call) 
+      (list* (movl (Simple (car arg*)) cpr) ; proc
+             (movl (pcb-ref 'frame-base) eax)
+             ; eax=baseofstack
+             (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler
+             (movl ebx (mem (fx- 0 wordsize) fpr)) ; set
+             ; create a new cont record
+             (movl (int continuation-tag) (mem 0 apr))
+             (movl fpr (mem disp-continuation-top apr))
+             ; compute the size of the captured frame
+             (movl eax ebx) 
+             (subl fpr ebx) 
+             (subl (int wordsize) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-size apr))
+             ; load next cont
+             (movl (pcb-ref 'next-continuation) ebx)
+             ; and store it
+             (movl ebx (mem disp-continuation-next apr))
+             ; adjust ap
+             (movl apr eax)
+             (addl (int vector-tag) eax)
+             (addl (int continuation-size) apr)
+             ; store new cont in current-cont
+             (movl eax (pcb-ref 'next-continuation))
+             ; adjust fp
+             (movl fpr (pcb-ref 'frame-base))
+             (subl (int wordsize) fpr)
+             ; tail-call f
+             (movl eax (mem (fx- 0 wordsize) fpr))
+             (movl (int (argc-convention 1)) eax)
+             (tail-indirect-cpr-call)
+             ac)]
+     [($code-size) 
+      (indirect-ref arg* (fx- disp-code-instrsize vector-tag)  ac)]
+     [($code-reloc-vector) 
+       (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)]
+     [($code-freevars) 
+       (indirect-ref arg* (fx- disp-code-freevars vector-tag) ac)]
+     [($set-car! $set-cdr! $vector-set! $string-set! $exit
+       $set-symbol-value! $set-symbol-plist! 
+       $code-set!  primitive-set! 
+       $set-code-object! $set-code-object+offset! $set-code-object+offset/rel!
+       $record-set!) 
+      (do-effect-prim op arg*
+        (cons (movl (int void-object) eax) ac))]
+     [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol?
+       procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq?
+       $char= $char< $char<= $char> $char>= $unbound-object? $code? 
+       $record? $record/rtd? bwp-object?) 
+      (do-pred->value-prim op arg* ac)]
+     [($code->closure)
+      (list* 
+        (movl (Simple (car arg*)) eax)
+        (addl (int (fx- disp-code-data vector-tag)) eax)
+        (movl eax (mem 0 apr))
+        (movl apr eax)
+        (addl (int closure-tag) eax)
+        (addl (int (align disp-closure-data)) apr)
+        ac)]
+     [($frame->continuation)
+      (NonTail 
+        (make-closure (make-code-loc SL_continuation_code) arg*)
+        ac)]
+     [($make-call-with-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_call_with_values) arg*)
+        ac)]
+     [($make-values-procedure)
+      (NonTail 
+        (make-closure (make-code-loc SL_values) arg*)
+        ac)]
+     [else
+      (error 'value-prim "unhandled ~s" op)]))
+  (define (indirect-assignment arg* offset ac)
+    (list*
+      (movl (Simple (car arg*)) eax)
+      (movl (Simple (cadr arg*)) ebx)
+      (movl ebx (mem offset eax))
+       ;;; record side effect
+      (addl (int offset) eax)
+      (shrl (int pageshift) eax)
+      (sall (int wordshift) eax)
+      (addl (pcb-ref 'dirty-vector) eax)
+      (movl (int dirty-word) (mem 0 eax))
+      ac))
+  (define (do-effect-prim op arg* ac)
+    (case op
+      [($vector-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (addl (int (fx- disp-vector-data vector-tag)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (movl eax (mem 0 ebx))
+              ;;; record side effect
+              (shrl (int pageshift) ebx)
+              (sall (int wordshift) ebx)
+              (addl (pcb-ref 'dirty-vector) ebx)
+              (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [($code-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (sall (int (fx- 8 fx-shift)) ebx)
+              (movb bh (mem (fx- disp-code-data vector-tag) eax))
+              ac)]
+      [($string-set!) 
+       (list* (movl (Simple (cadr arg*)) eax)
+              (sarl (int fx-shift) eax)
+              (addl (Simple (car arg*)) eax)
+              (movl (Simple (caddr arg*)) ebx)
+              (movb bh (mem (fx- disp-string-data string-tag) eax))
+              ac)]
+      [($set-car!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-car pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-cdr!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-cdr pair-tag) eax))
+               ;;; record side effect
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-tcbucket-key!)
+       (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)]
+      [($set-tcbucket-val!)
+       (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)]
+      [($set-tcbucket-next!)
+       (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)]
+      [($set-tcbucket-tconc!)
+       (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)]
+       
+      [($set-symbol-value!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [(primitive-set!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-system-value symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-plist!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-plist symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-unique-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)]
+      [($set-symbol-string!) 
+       (list* (movl (Simple (car arg*)) eax)
+              (movl (Simple (cadr arg*)) ebx)
+              (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax))
+               ;;; record side effect
+               (addl (int (fx- disp-symbol-string symbol-tag)) eax)
+               (shrl (int pageshift) eax)
+               (sall (int wordshift) eax)
+               (addl (pcb-ref 'dirty-vector) eax)
+               (movl (int dirty-word) (mem 0 eax))
+              ac)] 
+      [($record-set!) 
+       (list* (movl (Simple (car arg*)) ebx)
+              (addl (Simple (cadr arg*)) ebx)
+              (movl (Simple (caddr arg*)) eax)
+              (addl (int (fx- disp-record-data record-ptag)) ebx)
+              (movl eax (mem 0 ebx))
+               ;;; record side effect
+               (shrl (int pageshift) ebx)
+               (sall (int wordshift) ebx)
+               (addl (pcb-ref 'dirty-vector) ebx)
+               (movl (int dirty-word) (mem 0 ebx))
+              ac)]
+      [(cons void $fxadd1 $fxsub1 $record-ref)
+       (let f ([arg* arg*])
+         (cond
+           [(null? arg*) ac]
+           [else 
+            (Effect (car arg*) (f (cdr arg*)))]))]
+      [else 
+       (error 'do-effect-prim "unhandled op ~s" op)]))
+ (define (do-simple-test x Lt Lf ac)
+    (unless (or Lt Lf)
+      (error 'Pred "no labels"))
+    (cond
+      [(not Lt)
+       (list* (cmpl (int bool-f) x) (je Lf) ac)]
+      [(not Lf)
+       (list* (cmpl (int bool-f) x) (jne Lt) ac)]
+      [else
+       (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)]))
+  (define (Simple x)
+    (record-case x
+      [(cp-var i) 
+       (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)]
+      [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)]
+      [(constant c) (constant-val c)]
+      [(code-loc label) (label-address label)]
+      [(primref op) (primref-loc op)]
+      [else (error 'Simple "what ~s" x)]))
+  (define (closure-size x)
+    (align (fx+ disp-closure-data
+                (fx* wordsize (length (closure-free* x))))))
+  (define (assign-codes rhs* n* i ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (record-case (car rhs*)
+         [(closure label free*)
+          (cons (movl (Simple label) (mem i apr))
+                (assign-codes 
+                  (cdr rhs*) (cdr n*) (fx+ i (car n*)) ac))])]))
+  (define (whack-free x i n* rhs* ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let ([free (closure-free* (car rhs*))])
+         (let f ([free free] [j (fx+ i disp-closure-data)])
+           (cond
+             [(null? free) 
+              (whack-free x (fx+ i (car n*)) (cdr n*) (cdr rhs*) ac)]
+             [(eq? (car free) x)
+              (cons
+                (movl eax (mem j apr))
+                (f (cdr free) (fx+ j wordsize)))]
+             [else (f (cdr free) (fx+ j wordsize))])))]))
+  (define (assign-nonrec-free* rhs* all-rhs* n* seen ac)
+    (cond
+      [(null? rhs*) ac]
+      [else
+       (let f ([ls (closure-free* (car rhs*))] [seen seen])
+         (cond
+           [(null? ls) 
+            (assign-nonrec-free* (cdr rhs*) all-rhs* n* seen ac)]
+           [(memq (car ls) seen) (f (cdr ls) seen)]
+           [else
+            (cons
+              (movl (Simple (car ls)) eax)
+              (whack-free (car ls) 0 n* all-rhs*
+                (f (cdr ls) (cons (car ls) seen))))]))]))
+  (define (assign-rec-free* lhs* rhs* all-n* ac)
+    (list* (movl apr eax)
+           (addl (int closure-tag) eax)
+           (let f ([lhs* lhs*] [n* all-n*])
+             (cond
+               [(null? (cdr lhs*)) 
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs* ac))]
+               [else
+                (cons
+                  (movl eax (Simple (car lhs*)))
+                  (whack-free (car lhs*) 0 all-n* rhs*
+                    (cons
+                      (addl (int (car n*)) eax)
+                      (f (cdr lhs*) (cdr n*)))))]))))
+  (define (sum ac ls)
+    (cond
+      [(null? ls) ac]
+      [else (sum (fx+ ac (car ls)) (cdr ls))]))
+  (define (do-fix lhs* rhs* ac)
+    ;;; 1. first, set the code pointers in the right places
+    ;;; 2. next, for every variable appearing in the rhs* but is not in
+    ;;;    the lhs*, load it once and set it everywhere it occurs.
+    ;;; 3. next, compute the values of the lhs*, and for every computed
+    ;;;    value, store it on the stack, and set it everywhere it occurs
+    ;;;    in the rhs*
+    ;;; 4. that's it.
+    (let* ([n* (map closure-size rhs*)])
+      (assign-codes rhs* n* 0
+        (assign-nonrec-free* rhs* rhs* n* lhs*
+          (assign-rec-free* lhs* rhs* n*
+            (cons (addl (int (sum 0 n*)) apr) ac))))))
+  (define (frame-adjustment offset)
+    (fx* (fxsub1 offset) (fx- 0 wordsize)))
+  (define (NonTail x ac) 
+    (record-case x
+      [(constant c)
+       (cons (movl (constant-val c) eax) ac)]
+      [(frame-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(cp-var)
+       (cons (movl (Simple x) eax) ac)]
+      [(foreign-label L) 
+       (cons (movl (list 'foreign-label L) eax) ac)]
+      [(primref c)
+       (cons (movl (primref-loc c) eax) ac)]
+      [(closure label arg*)
+       (let f ([arg* arg*] [off disp-closure-data])
+         (cond
+           [(null? arg*)
+            (list* (movl (Simple label) (mem 0 apr))
+                   (movl apr eax)
+                   (addl (int (align off)) apr)
+                   (addl (int closure-tag) eax)
+                   ac)]
+           [else
+            (list* (movl (Simple (car arg*)) eax)
+                   (movl eax (mem off apr))
+                   (f (cdr arg*) (fx+ off wordsize)))]))]
+      [(conditional test conseq altern)
+       (let ([Lj (unique-label)] [Lf (unique-label)])
+         (Pred test #f Lf
+           (NonTail conseq
+             (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))]
+      [(seq e0 e1)
+       (Effect e0 (NonTail e1 ac))]
+      [(fix lhs* rhs* body)
+       (do-fix lhs* rhs* (NonTail body ac))]
+      [(primcall op rand*)
+       (do-value-prim op rand* ac)]
+      [(new-frame base-idx size body)
+       (NonTail body ac)]
+      [(call-cp call-convention rp-convention offset size mask)
+       (let ([L_CALL (unique-label)])
+         (case call-convention
+           [(normal)
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   `(byte-vector ,mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention)
+                   `(byte 0) ; padding for indirect calls only
+                   `(byte 0) ; direct calls are ok
+                   L_CALL
+                   (indirect-cpr-call)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [(foreign) 
+            (list* (addl (int (frame-adjustment offset)) fpr)
+                   (movl (int (argc-convention size)) eax)
+                   (movl '(foreign-label "ik_foreign_call") ebx)
+                   (jmp L_CALL)
+                   ; NEW FRAME
+                   (byte-vector mask)
+                   `(int ,(fx* offset wordsize))
+                   `(current-frame-offset)
+                   (rp-label rp-convention) ; should be 0, since C has 1 rv
+                   '(byte 0)
+                   '(byte 0)
+                   '(byte 0)
+                   L_CALL
+                   (call ebx)
+                   (movl (mem 0 fpr) cpr)
+                   (subl (int (frame-adjustment offset)) fpr)
+                   ac)]
+           [else
+            (error who "invalid convention ~s for call-cp" call-convention)]))]
+      [else (error 'NonTail "invalid expression ~s" x)]))
+  (define (Pred x Lt Lf ac)
+    (record-case x
+      [(frame-var i) 
+       (do-simple-test (idx->frame-loc i) Lt Lf ac)]
+      [(cp-var i) 
+       (do-simple-test (Simple x) Lt Lf ac)]
+      [(constant c) 
+       (if c
+           (if Lt (cons (jmp Lt) ac) ac)
+           (if Lf (cons (jmp Lf) ac) ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Pred body Lt Lf ac))]
+      [(primcall op rand*)
+       (do-pred-prim op rand* Lt Lf ac)]
+      [(conditional test conseq altern)
+       (cond
+         [(not Lt) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lj^ Lf
+                (cons Lf^
+                  (Pred altern #f Lf 
+                    (cons Lj^ ac))))))]
+         [(not Lf) 
+          (let ([Lj^ (unique-label)] [Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lj^
+                (cons Lf^
+                  (Pred altern Lt #f 
+                    (cons Lj^ ac))))))]
+         [else 
+          (let ([Lf^ (unique-label)])
+            (Pred test #f Lf^
+              (Pred conseq Lt Lf
+                (cons Lf^
+                  (Pred altern Lt Lf ac)))))])] 
+      [(seq e0 e1)
+       (Effect e0 (Pred e1 Lt Lf ac))]
+      [(new-frame)
+       (NonTail x (do-simple-test eax Lt Lf ac))]
+      [else (error 'Pred "invalid expression ~s" x)]))
+  (define (idx->frame-loc i)
+    (mem (fx* i (fx- 0 wordsize)) fpr))
+  (define (Effect x ac)
+   (record-case x
+     [(constant) ac]
+     [(primcall op rand*)
+      (do-effect-prim op rand* ac)]
+     [(conditional test conseq altern)
+      (let* ([Ljoin (unique-label)]
+             [ac (cons Ljoin ac)]
+             [altern-ac (Effect altern ac)])
+        (cond
+          [(eq? altern-ac ac) ;; altern is nop
+           (let* ([conseq-ac (Effect conseq ac)])
+             (cond
+               [(eq? conseq-ac ac) ;; conseq is nop too!
+                (Effect test ac)]
+               [else  ; "when" pattern
+                (Pred test #f Ljoin conseq-ac)]))]
+          [else 
+           (let* ([Lf (unique-label)]
+                  [nac (list* (jmp Ljoin) Lf altern-ac)]
+                  [conseq-ac (Effect conseq nac)])
+             (cond
+               [(eq? conseq-ac nac) ;; "unless" pattern"
+                (Pred test Ljoin #f altern-ac)]
+               [else
+                (Pred test #f Lf conseq-ac)]))]))]
+;;;  [(conditional test conseq altern)
+;;;   (let ([Lf (unique-label)] [Ljoin (unique-label)])
+;;;     (Pred test #f Lf
+;;;       (Effect conseq
+;;;         (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))]
+     [(seq e0 e1)
+      (Effect e0 (Effect e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Effect body ac))]
+     [(assign loc val)
+      (record-case loc
+        [(frame-var i)
+         (record-case val
+           [(constant c) 
+            (cons (movl (constant-val c) (idx->frame-loc i)) ac)]
+           [else
+            (NonTail val
+              (cons (movl eax (idx->frame-loc i)) ac))])]
+        [else (error who "invalid assign loc ~s" loc)])]
+     [(eval-cp check body)
+      (cond
+        [check
+         (NonTail body
+           (list* 
+             (movl eax cpr)
+             (andl (int closure-mask) eax)
+             (cmpl (int closure-tag) eax)
+             (jne (label SL_nonprocedure))
+             ac))]
+        [(primref? body)
+         (list* (movl (primref-loc (primref-name body)) cpr) ac)]
+        [else
+         (NonTail body (list* (movl eax cpr) ac))])]
+     [(save-cp loc)
+      (record-case loc
+        [(frame-var i)
+         (cons (movl cpr (idx->frame-loc i)) ac)]
+        [else (error who "invalid cpr loc ~s" x)])]
+     [(new-frame) (NonTail x ac)]
+     [(frame-var) ac]
+     [else (error 'Effect "invalid expression ~s" x)]))
+  (define (Tail x ac) 
+    (record-case x
+     [(return x) 
+      (NonTail x (cons (ret) ac))]
+     [(conditional test conseq altern)
+      (let ([L (unique-label)])
+        (Pred test #f L
+          (Tail conseq 
+            (cons L (Tail altern ac)))))]
+     [(seq e0 e1)
+      (Effect e0 (Tail e1 ac))]
+     [(fix lhs* rhs* body)
+      (do-fix lhs* rhs* (Tail body ac))]
+     [(new-frame idx size body)
+      (Tail body ac)]
+     [(tailcall-cp call-convention argc)
+      (list* 
+        (movl (int (argc-convention argc)) eax)
+        (case call-convention
+          [(normal) (tail-indirect-cpr-call)]
+          [(apply)  (jmp (label SL_apply))]
+          [else 
+           (error who "invalid tail-call convention ~s" call-convention)])
+        ac)]
+;;;     [(call-cp call-convention rp-convention idx argc mask)
+;;;      (unless (eq? rp-convention 'tail)
+;;;        (error who "nontail rp (~s) in tail context" rp-convention))
+;;;      (let f ([i 0])
+;;;        (cond
+;;;          [(fx= i argc)
+;;;           (case call-convention
+;;;             [(normal) 
+;;;              (list* 
+;;;                (movl (int (argc-convention argc)) eax)
+;;;                (tail-indirect-cpr-call)
+;;;                ac)]
+;;;             [(apply)
+;;;              (list* 
+;;;                (movl (int (argc-convention argc)) eax)
+;;;                (jmp (label SL_apply)) 
+;;;                ac)]
+;;;             [else
+;;;              (error who "invalid conv ~s in tail call-cpr" call-convention)])]
+;;;          [else
+;;;            (list* (movl (mem (fx* (fx+ idx (fxadd1 i))
+;;;                                   (fx- 0 wordsize)) fpr)
+;;;                         eax)
+;;;                   (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr))
+;;;                   (f (fxadd1 i)))]))]
+     [else (error 'Tail "invalid expression ~s" x)]))
+  (define (handle-vararg fml-count ac)
+    (define CONTINUE_LABEL (unique-label))
+    (define DONE_LABEL (unique-label))
+    (define CONS_LABEL (unique-label))
+    (define LOOP_HEAD (unique-label))
+    (define L_CALL (unique-label))
+    (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax)
+           (jg (label SL_invalid_args))
+           (jl CONS_LABEL)
+           (movl (int nil) ebx)
+           (jmp DONE_LABEL)
+           CONS_LABEL
+           (movl (pcb-ref 'allocation-redline) ebx)
+           (addl eax ebx)
+           (addl eax ebx)
+           (cmpl ebx apr)
+           (jle LOOP_HEAD)
+           ; overflow
+           (addl eax esp) ; advance esp to cover args
+           (pushl cpr)    ; push current cp
+           (pushl eax)    ; push argc
+           (negl eax)     ; make argc positive
+           (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size
+           (pushl eax)    ; push frame size
+           (addl eax eax) ; double the number of args
+           (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg
+           (movl (int (argc-convention 1)) eax) ; setup argc
+           (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler
+           (jmp L_CALL)   ; go to overflow handler
+           ; NEW FRAME
+           (int 0)        ; if the framesize=0, then the framesize is dynamic
+           '(current-frame-offset)
+           (int 0)        ; multiarg rp
+           (byte 0)
+           (byte 0)
+           L_CALL
+           (indirect-cpr-call)
+           (popl eax)     ; pop framesize and drop it
+           (popl eax)     ; reload argc
+           (popl cpr)     ; reload cp
+           (subl eax fpr) ; readjust fp
+           LOOP_HEAD
+           (movl (int nil) ebx)
+           CONTINUE_LABEL
+           (movl ebx (mem disp-cdr apr))
+           (movl (mem fpr eax) ebx)
+           (movl ebx (mem disp-car apr))
+           (movl apr ebx)
+           (addl (int pair-tag) ebx)
+           (addl (int pair-size) apr)
+           (addl (int (fxsll 1 fx-shift)) eax)
+           (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax)
+           (jle CONTINUE_LABEL)
+           DONE_LABEL
+           (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr))
+           ac))
+  (define (Entry check? x ac)
+    (record-case x
+      [(clambda-case fml* proper body)
+       (let ([ac (Tail body ac)])
+         (cond
+           [(and proper check?)
+            (list* (cmpl (int (argc-convention (length fml*))) eax)
+                   (jne (label SL_invalid_args))
+                   ac)]
+           [proper ac]
+           [else
+            (handle-vararg (length fml*) ac)]))]))
+  (define make-dispatcher
+    (lambda (j? L L* x x* ac)
+      (cond
+        [(null? L*) (if j? (cons (jmp (label L)) ac) ac)]
+        [else
+         (record-case x
+           [(clambda-case fml* proper _)
+            (cond
+              [proper
+               (list* (cmpl (int (argc-convention (length fml*))) eax)
+                      (je (label L))
+                      (make-dispatcher #t 
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))]
+              [else
+               (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax)
+                      (jle (label L))
+                      (make-dispatcher #t
+                        (car L*) (cdr L*) (car x*) (cdr x*) ac))])])])))
+  (define (handle-cases x x*)
+    (let ([L* (map (lambda (_) (gensym)) x*)]
+          [L (gensym)])
+      (make-dispatcher #f L L* x x*
+        (let f ([x x] [x* x*] [L L] [L* L*])
+          (cond
+            [(null? x*) 
+             (cons (label L) (Entry 'check x '()))]
+            [else
+             (cons (label L)
+               (Entry #f x
+                 (f (car x*) (cdr x*) (car L*) (cdr L*))))])))))
+  (define (CodeExpr x)
+    (record-case x
+      [(clambda-code L cases free)
+       (list*
+         (length free)
+         (label L)
+         (handle-cases (car cases) (cdr cases)))]))
+  (record-case x
+    [(codes list body)
+     (cons (cons 0 (Tail body '()))
+           (map CodeExpr list))]))
+
+
+(define SL_nonprocedure (gensym "SL_nonprocedure"))
+
+(define SL_top_level_value_error (gensym "SL_top_level_value_error"))
+(define SL_car_error (gensym "SL_car_error"))
+(define SL_cdr_error (gensym "SL_cdr_error"))
+
+(define SL_invalid_args (gensym "SL_invalid_args"))
+(define SL_foreign_call (gensym "SL_foreign_call"))
+(define SL_continuation_code (gensym "SL_continuation_code"))
+(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp"))
+(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp"))
+(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values"))
+(define SL_underflow_handler (gensym "SL_underflow_handler"))
+(define SL_scheme_exit (gensym "SL_scheme_exit"))
+(define SL_apply (gensym "SL_apply"))
+(define SL_values (gensym "SL_values"))
+(define SL_call_with_values (gensym "SL_call_with_values"))
+
+(module ()
+(list*->code*
+  (list
+    (list 0
+          (label SL_car_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'car-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_cdr_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'cdr-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_top_level_value_error)
+          (movl ebx (mem (fx- 0 wordsize) fpr))
+          (movl (primref-loc 'top-level-value-error) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([L_cwv_done (gensym)]
+          [L_cwv_loop (gensym)]
+          [L_cwv_multi_rp (gensym)]
+          [L_cwv_call (gensym)])
+      (list 
+          0 ; no free vars
+          (label SL_call_with_values)
+          (cmpl (int (argc-convention 2)) eax)
+          (jne (label SL_invalid_args))
+          (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer
+          (movl ebx cpr)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (movl (int (argc-convention 0)) eax)
+          (subl (int (fx* wordsize 2)) fpr)
+          (jmp (label L_cwv_call))
+          ; MV NEW FRAME
+          (byte-vector '#(#b110))
+          (int (fx* wordsize 3))
+           '(current-frame-offset)
+          (label-address L_cwv_multi_rp)
+          (byte 0)
+          (byte 0)
+          (label L_cwv_call)
+          (indirect-cpr-call)
+          ;;; one value returned
+          (addl (int (fx* wordsize 2)) fpr)
+          (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer
+          (movl ebx cpr)
+          (movl eax (mem (fx- 0 wordsize) fpr))
+          (movl (int (argc-convention 1)) eax)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)
+          ;;; multiple values returned
+          (label L_cwv_multi_rp)
+          ; because values does not pop the return point
+          ; we have to adjust fp one more word here
+          (addl (int (fx* wordsize 3)) fpr) 
+          (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer
+          (cmpl (int (argc-convention 0)) eax)
+          (je (label L_cwv_done))
+          (movl (int (fx* -4 wordsize)) ebx)
+          (addl fpr ebx)  ; ebx points to first value
+          (movl ebx ecx)
+          (addl eax ecx)  ; ecx points to the last value
+          (label L_cwv_loop)
+          (movl (mem 0 ebx) edx)
+          (movl edx (mem (fx* 3 wordsize) ebx))
+          (subl (int wordsize) ebx)
+          (cmpl ecx ebx)
+          (jge (label L_cwv_loop))
+          (label L_cwv_done)
+          (movl cpr ebx)
+          (andl (int closure-mask) ebx)
+          (cmpl (int closure-tag) ebx)
+          (jne (label SL_nonprocedure))
+          (tail-indirect-cpr-call)))
+
+    (let ([L_values_one_value (gensym)]
+          [L_values_many_values (gensym)])
+      (list 0 ; no freevars
+          (label SL_values)
+          (cmpl (int (argc-convention 1)) eax)
+          (je (label L_values_one_value))
+          (label L_values_many_values)
+          (movl (mem 0 fpr) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))     ; go
+          (label L_values_one_value)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (ret)))
+
+    (let ([L_apply_done (gensym)]
+          [L_apply_loop (gensym)])
+      (list 0 
+          (label SL_apply)
+          (movl (mem fpr eax) ebx)
+          (cmpl (int nil) ebx)
+          (je (label L_apply_done))
+          (label L_apply_loop)
+          (movl (mem (fx- disp-car pair-tag) ebx) ecx)
+          (movl (mem (fx- disp-cdr pair-tag) ebx) ebx)
+          (movl ecx (mem fpr eax))
+          (subl (int wordsize) eax)
+          (cmpl (int nil) ebx)
+          (jne (label L_apply_loop))
+          (label L_apply_done)
+          (addl (int wordsize) eax)
+          (tail-indirect-cpr-call)))
+
+    (list 0
+          (label SL_nonprocedure)
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (movl (primref-loc '$apply-nonprocedure-error-handler) cpr)
+          (movl (int (argc-convention 1)) eax)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_error_rp)
+          (movl (primref-loc '$multiple-values-error) cpr)
+          (tail-indirect-cpr-call))
+
+    (list 0
+          (label SL_multiple_values_ignore_rp)
+          (ret))
+
+    (list 0
+          (label SL_invalid_args)
+          ;;;
+          (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg
+          (negl eax)
+          (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr))
+          (movl (primref-loc '$incorrect-args-error-handler) cpr)
+          (movl (int (argc-convention 2)) eax)
+          (tail-indirect-cpr-call))
+
+    (let ([Lset (gensym)] [Lloop (gensym)])
+      (list 0
+          (label SL_foreign_call)
+          (movl fpr (pcb-ref 'frame-pointer))
+          (movl apr (pcb-ref 'allocation-pointer))
+          (movl fpr ebx)
+          (movl (pcb-ref 'system-stack) esp)
+          (pushl pcr)
+          (cmpl (int 0) eax)
+          (je (label Lset))
+          (label Lloop)
+          (movl (mem ebx eax) ecx)
+          (pushl ecx)
+          (addl (int 4) eax)
+          (cmpl (int 0) eax)
+          (jne (label Lloop))
+          (label Lset)
+          ; FOREIGN NEW FRAME
+          (call cpr)
+          (movl (pcb-ref 'frame-pointer) fpr)
+          (movl (pcb-ref 'allocation-pointer) apr)
+          (ret)))
+
+    (let ([L_cont_zero_args      (gensym)] 
+          [L_cont_mult_args      (gensym)]
+          [L_cont_one_arg        (gensym)]
+          [L_cont_mult_move_args (gensym)]
+          [L_cont_mult_copy_loop (gensym)])
+      (list  1 ; freevars
+          (label SL_continuation_code)
+          (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k
+          (movl ebx (pcb-ref 'next-continuation)) ; set
+          (movl (pcb-ref 'frame-base) ebx)
+          (cmpl (int (argc-convention 1)) eax)
+          (jg (label L_cont_zero_args))
+          (jl (label L_cont_mult_args))
+          (label L_cont_one_arg)
+          (movl (mem (fx- 0 wordsize) fpr) eax)
+          (movl ebx fpr)
+          (subl (int wordsize) fpr)
+          (ret)
+          (label L_cont_zero_args)
+          (subl (int wordsize) ebx)
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx) ; return point
+          (jmp (mem disp-multivalue-rp ebx))  ; go
+          (label L_cont_mult_args)
+          (subl (int wordsize) ebx)
+          (cmpl ebx fpr)
+          (jne (label L_cont_mult_move_args))
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          (label L_cont_mult_move_args)
+          ; move args from fpr to ebx
+          (movl (int 0) ecx)
+          (label L_cont_mult_copy_loop)
+          (subl (int wordsize) ecx)
+          (movl (mem fpr ecx) edx)
+          (movl edx (mem ebx ecx))
+          (cmpl ecx eax)
+          (jne (label L_cont_mult_copy_loop))
+          (movl ebx fpr)
+          (movl (mem 0 ebx) ebx)
+          (jmp (mem disp-multivalue-rp ebx))
+          ))
+    )))
+
+
+
+(define (compile-expr expr)
+  (let* ([p (recordize expr)]
+         [p (optimize-direct-calls p)]
+;;;         [foo (analyze-cwv p)]
+         [p (optimize-letrec p)]
+         ;[p (remove-letrec p)]
+         [p (remove-assignments p)]
+         [p (convert-closures p)]
+         [p (lift-codes p)]
+         [p (introduce-primcalls p)]
+         [p (simplify-operands p)]
+         [p (insert-stack-overflow-checks p)]
+         [p (insert-allocation-checks p)]
+         [p (remove-local-variables p)]
+         [p (optimize-ap-check p)]
+         [ls* (generate-code p)]
+         [f (when (assembler-output)
+              (for-each 
+                (lambda (ls)
+                  (for-each (lambda (x) (printf "    ~s\n" x)) ls))
+                ls*))]
+         [code* (list*->code* ls*)])
+    (car code*)))
+
+(define compile-file
+  (lambda (input-file output-file . rest)
+    (let ([ip (open-input-file input-file)]
+          [op (apply open-output-file output-file rest)])
+      (let f ()
+        (let ([x (read ip)])
+          (unless (eof-object? x)
+            (fasl-write (compile-expr (expand x)) op)
+            (f))))
+      (close-input-port ip)
+      (close-output-port op))))
+
+(primitive-set! 'compile-file compile-file)
+(primitive-set! 'assembler-output (make-parameter #f))
+(primitive-set! 'compile
+  (lambda (x)
+    (let ([code (compile-expr (expand x))])
+      (let ([proc ($code->closure code)])
+        (proc)))))
+
+)
+
diff --git a/src/libcontrol.fasl b/src/libcontrol.fasl
index d86b21b..aabf1e3 100644
Binary files a/src/libcontrol.fasl and b/src/libcontrol.fasl differ
diff --git a/src/libcore-6.9.ss b/src/libcore-6.9.ss
new file mode 100644
index 0000000..680b691
--- /dev/null
+++ b/src/libcore-6.9.ss
@@ -0,0 +1,1664 @@
+
+;;; 6.9: * removed uuid
+;;;      * top-level-value is now open-coded.
+;;;
+;;; 6.2: * added bwp-object?, weak-cons, weak-pair?
+;;;      * pointer-value
+;;; 6.1: * added uses of case-lambda to replace the ugly code 
+;;; 6.0: * basic version working
+
+
+(primitive-set! 'call-with-values 
+  ($make-call-with-values-procedure))
+
+(primitive-set! 'values 
+  ($make-values-procedure))
+
+(primitive-set! 'exit
+  (case-lambda
+    [() (exit 0)]
+    [(status) (foreign-call "exit" status)]))
+
+(primitive-set! 'eof-object
+  (lambda () (eof-object)))
+
+(primitive-set! 'void
+  (lambda () (void)))
+  
+(primitive-set! 'eof-object?
+  (lambda (x) (eof-object? x)))
+
+(primitive-set! 'fxadd1
+  (lambda (n)
+    (unless (fixnum? n)
+      (error 'fxadd1 "~s is not a fixnum" n))
+    ($fxadd1 n)))
+  
+(primitive-set! 'fxsub1 
+  (lambda (n) 
+    (unless (fixnum? n)
+      (error 'fxsub1 "~s is not a fixnum" n))
+    ($fxsub1 n)))
+  
+(primitive-set! 'integer->char
+  (lambda (n)
+    (unless (fixnum? n)
+      (error 'integer->char "~s is not a fixnum" n))
+    (unless (and ($fx>= n 0)
+                 ($fx<= n 255))
+      (error 'integer->char "~s is out of range[0..255]" n))
+    ($fixnum->char n)))
+  
+(primitive-set! 'char->integer 
+  (lambda (x) 
+    (unless (char? x)
+      (error 'char->integer "~s is not a character" x))
+    ($char->fixnum x)))
+  
+(primitive-set! 'fxlognot 
+  (lambda (x)
+    (unless (fixnum? x) 
+      (error 'fxlognot "~s is not a fixnum" x))
+    ($fxlognot x)))
+  
+(primitive-set! 'fixnum? (lambda (x) (fixnum? x)))
+(primitive-set! 'immediate? (lambda (x) (immediate? x)))
+
+(primitive-set! 'fxzero? 
+  (lambda (x)
+    (unless (fixnum? x)
+      (error 'fxzero? "~s is not a fixnum" x))
+    ($fxzero? x)))
+
+(primitive-set! 'boolean? (lambda (x) (boolean? x)))
+  
+(primitive-set! 'char? (lambda (x) (char? x)))
+
+(primitive-set! 'vector? (lambda (x) (vector? x)))
+
+(primitive-set! 'string? (lambda (x) (string? x)))
+
+(primitive-set! 'procedure? (lambda (x) (procedure? x)))
+
+(primitive-set! 'null? (lambda (x) (null? x)))
+
+(primitive-set! 'pair? (lambda (x) (pair? x)))
+
+(let ()
+  (define fill!
+    (lambda (v i n fill)
+      (cond
+        [($fx= i n) v]
+        [else
+         ($vector-set! v i fill)
+         (fill! v ($fx+ i 1) n fill)])))
+  (define make-vector
+    (case-lambda
+      [(n) (make-vector n (void))]
+      [(n fill)
+       (unless (and (fixnum? n) (fx>= n 0))
+         (error 'make-vector "~s is not a valid length" n))
+       (fill! ($make-vector n) 0 n fill)]))
+  (primitive-set! 'make-vector make-vector))
+
+(primitive-set! 'vector-length
+  (lambda (x)
+    (unless (vector? x) 
+      (error 'vector-length "~s is not a vector" x))
+    ($vector-length x)))
+
+(let ()
+  (define fill!
+    (lambda (s i n c)
+      (cond
+        [($fx= i n) s]
+        [else
+         ($string-set! s i c)
+         (fill! s ($fx+ i 1) n c)])))
+  (define make-string
+    (case-lambda
+      [(n) 
+       (unless (and (fixnum? n) (fx>= n 0))
+         (error 'make-string "~s is not a valid length" n))
+       ($make-string n)]
+      [(n c)
+       (unless (and (fixnum? n) (fx>= n 0))
+         (error 'make-string "~s is not a valid length" n))
+       (unless (char? c)
+         (error 'make-string "~s is not a character" c))
+       (fill! ($make-string n) 0 n c)]))
+  (primitive-set! 'make-string make-string))
+
+
+(primitive-set! 'string-length
+  (lambda (x)
+    (unless (string? x)
+      (error 'string-length "~s is not a string" x))
+    ($string-length x)))
+
+(primitive-set! 'string->list
+  (lambda (x)
+    (unless (string? x)
+      (error 'string->list "~s is not a string" x))
+    (let f ([x x] [i ($string-length x)] [ac '()])
+      (cond
+        [($fxzero? i) ac]
+        [else
+         (let ([i ($fxsub1 i)])
+           (f x i (cons ($string-ref x i) ac)))]))))
+
+
+(let ()
+  (define bstring=?
+    (lambda (s1 s2 i j)
+      (or ($fx= i j)
+          (and ($char= ($string-ref s1 i) ($string-ref s2 i))
+               (bstring=? s1 s2 ($fxadd1 i) j)))))
+  (define check-strings-and-return-false
+    (lambda (s*)
+      (cond
+        [(null? s*) #f]
+        [(string? ($car s*)) 
+         (check-strings-and-return-false ($cdr s*))]
+        [else (err ($car s*))])))
+  (define strings=?
+    (lambda (s s* n)
+      (or (null? s*)
+          (let ([a ($car s*)])
+            (unless (string? a)
+              (error 'string=? "~s is not a string" a))
+            (if ($fx= n ($string-length a))
+                (and (strings=? s ($cdr s*) n)
+                     (bstring=? s a 0 n))
+                (check-strings-and-return-false ($cdr s*)))))))
+  (define (err x)
+    (error 'string=? "~s is not a string" x))
+  (primitive-set! 'string=?
+    (case-lambda
+      [(s s1) 
+       (if (string? s) 
+           (if (string? s1)
+               (let ([n ($string-length s)])
+                 (and ($fx= n ($string-length s1))
+                      (bstring=? s s1 0 n)))
+               (err s1))
+           (err s))]
+      [(s . s*)
+       (if (string? s)
+           (strings=? s s* ($string-length s))
+           (err s))])))
+
+
+
+(let ()
+  ;; FIXME: make nonconsing on 0,1,2, and 3 args
+  (define length*
+    (lambda (s* n)
+      (cond
+        [(null? s*) n]
+        [else
+         (let ([a ($car s*)])
+           (unless (string? a) 
+             (error 'string-append "~s is not a string" a))
+           (length* ($cdr s*) ($fx+ n ($string-length a))))])))
+  (define fill-string
+    (lambda (s a si sj ai)
+      (unless ($fx= si sj)
+        ($string-set! s si ($string-ref a ai))
+        (fill-string s a ($fxadd1 si) sj ($fxadd1 ai)))))
+  (define fill-strings
+    (lambda (s s* i)
+      (cond
+        [(null? s*) s]
+        [else
+         (let ([a ($car s*)])
+           (let ([n ($string-length a)])
+             (let ([j ($fx+ i n)])
+               (fill-string s a i j 0)
+               (fill-strings s ($cdr s*) j))))])))
+  (primitive-set! 'string-append
+    (lambda s*
+      (let ([n (length* s* 0)])
+        (let ([s ($make-string n)])
+          (fill-strings s s* 0))))))
+
+
+(let ()
+  (define fill
+    (lambda (s d si sj di)
+      (cond
+        [($fx= si sj) d]
+        [else
+         ($string-set! d di ($string-ref s si))
+         (fill s d ($fxadd1 si) sj ($fxadd1 di))])))
+  (primitive-set! 'substring
+     (lambda (s n m)
+       (unless (string? s)
+         (error 'substring "~s is not a string" s))
+       (let ([len ($string-length s)])
+         (unless (and (fixnum? n)
+                      ($fx>= n 0)
+                      ($fx< n len))
+           (error 'substring "~s is not a valid start index for ~s" n s))
+         (unless (and (fixnum? m)
+                      ($fx>= m 0)
+                      ($fx<= m len))
+           (error 'substring "~s is not a valid end index for ~s" m s))
+         (let ([len ($fx- m n)])
+           (if ($fx<= len 0)
+               ""
+               (fill s ($make-string len) n m 0)))))))
+
+(primitive-set! 'not (lambda (x) (not x)))
+  
+(primitive-set! 'symbol->string
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'symbol->string "~s is not a symbol" x))
+    (let ([str ($symbol-string x)])
+      (or str
+          (let ([ct (gensym-count)])
+            (let ([str (string-append (gensym-prefix) (fixnum->string ct))])
+              ($set-symbol-string! x str)
+              (gensym-count ($fxadd1 ct))
+              str))))))
+
+(primitive-set! 'gensym?
+  (lambda (x)
+    (and (symbol? x) 
+         (let ([s ($symbol-unique-string x)])
+           (and s #t)))))
+
+(let ()
+  (define f
+    (lambda (n i j)
+      (cond
+        [($fxzero? n) 
+         (values (make-string i) j)]
+        [else
+         (let ([q ($fxquotient n 10)])
+           (call-with-values
+             (lambda () (f q ($fxadd1 i) j))
+             (lambda (str j)
+               (let ([r ($fx- n ($fx* q 10))])
+                 (string-set! str j
+                    ($fixnum->char ($fx+ r ($char->fixnum #\0))))
+                 (values str ($fxadd1 j))))))])))
+  (primitive-set! 'fixnum->string
+    (lambda (x)
+      (unless (fixnum? x) (error 'fixnum->string "~s is not a fixnum" x))
+      (cond
+        [($fxzero? x) "0"]
+        [($fx> x 0) 
+         (call-with-values
+           (lambda () (f x 0 0))
+           (lambda (str j) str))]
+        [($fx= x -536870912) "-536870912"]
+        [else
+         (call-with-values
+           (lambda () (f ($fx- 0 x) 1 1))
+           (lambda (str j)
+             ($string-set! str 0 #\-)
+             str))]))))
+
+;;; OLD (primitive-set! 'top-level-value
+;;; OLD   (lambda (x)
+;;; OLD     (unless (symbol? x)
+;;; OLD       (error 'top-level-value "~s is not a symbol" x))
+;;; OLD     (let ([v ($symbol-value x)])
+;;; OLD       (when ($unbound-object? v)
+;;; OLD         (error 'top-level-value "unbound variable ~s" x))
+;;; OLD       v)))
+
+(primitive-set! 'top-level-value
+  (lambda (x)
+    (top-level-value x)))
+
+(primitive-set! 'top-level-bound?
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'top-level-bound? "~s is not a symbol" x))
+    (not ($unbound-object? ($symbol-value x)))))
+
+(primitive-set! 'set-top-level-value!
+  (lambda (x v)
+    (unless (symbol? x)
+      (error 'set-top-level-value! "~s is not a symbol" x))
+    ($set-symbol-value! x v)))
+ 
+(primitive-set! 'symbol? (lambda (x) (symbol? x)))
+  
+(primitive-set! 'primitive?
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'primitive? "~s is not a symbol" x))
+    (procedure? (primitive-ref x))))
+
+(primitive-set! 'primitive-ref
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'primitive-ref "~s is not a symbol" x))
+    (let ([v (primitive-ref x)])
+      (unless (procedure? v)
+        (error 'primitive-ref "~s is not a primitive" x))
+      v)))
+
+(primitive-set! 'primitive-set!
+  (lambda (x v)
+    (unless (symbol? x)
+      (error 'primitive-set! "~s is not a symbol" x))
+    (primitive-set! x v)
+    (set-top-level-value! x v)))
+
+
+
+
+
+(primitive-set! 'fx+ 
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx+ "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx+ "~s is not a fixnum" y))
+    ($fx+ x y)))
+
+(primitive-set! 'fx-
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx- "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx- "~s is not a fixnum" y))
+    ($fx- x y)))
+  
+(primitive-set! 'fx*
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx* "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx* "~s is not a fixnum" y))
+    ($fx* x y)))
+  
+
+
+(primitive-set! 'fxquotient
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxquotient "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxquotient "~s is not a fixnum" y))
+    (when ($fxzero? y)
+      (error 'fxquotient "zero dividend ~s" y))
+    ($fxquotient x y))) 
+
+
+(primitive-set! 'fxremainder
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxremainder "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxremainder "~s is not a fixnum" y))
+    (when ($fxzero? y)
+      (error 'fxremainder "zero dividend ~s" y))
+    (let ([q ($fxquotient x y)])
+      ($fx- x ($fx* q y)))))
+ 
+
+(primitive-set! 'fxmodulo
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxmodulo "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxmodulo "~s is not a fixnum" y))
+    (when ($fxzero? y)
+      (error 'fxmodulo "zero dividend ~s" y))
+    ($fxmodulo x y)))
+
+
+(primitive-set! 'fxlogor
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxlogor "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxlogor "~s is not a fixnum" y))
+    ($fxlogor x y)))
+
+(primitive-set! 'fxlogxor
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxlogxor "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxlogxor "~s is not a fixnum" y))
+    ($fxlogxor x y)))
+  
+(primitive-set! 'fxlogand
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxlogand "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxlogand "~s is not a fixnum" y))
+    ($fxlogand x y)))
+ 
+(primitive-set! 'fxsra
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxsra "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxsra "~s is not a fixnum" y))
+    (unless ($fx>= y 0)
+      (error 'fxsra "negative shift not allowed, got ~s" y))
+    ($fxsra x y)))
+ 
+(primitive-set! 'fxsll
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fxsll "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fxsll "~s is not a fixnum" y))
+    (unless ($fx>= y 0)
+      (error 'fxsll "negative shift not allowed, got ~s" y))
+    ($fxsll x y))) 
+
+(primitive-set! 'fx=
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx= "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx= "~s is not a fixnum" y))
+    ($fx= x y))) 
+
+(primitive-set! 'fx<
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx< "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx< "~s is not a fixnum" y))
+    ($fx< x y)))
+
+(primitive-set! 'fx<=
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx<= "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx<= "~s is not a fixnum" y))
+    ($fx<= x y)))
+ 
+(primitive-set! 'fx>
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx> "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx> "~s is not a fixnum" y))
+    ($fx> x y)))
+
+(primitive-set! 'fx>=
+  (lambda (x y) 
+    (unless (fixnum? x)
+      (error 'fx>= "~s is not a fixnum" x))
+    (unless (fixnum? y)
+      (error 'fx>= "~s is not a fixnum" y))
+    ($fx>= x y)))
+  
+
+(primitive-set! 'char=?
+  (let ()
+    (define (err x)
+      (error 'char=? "~s is not a character" x))
+    (case-lambda
+      [(c1 c2)
+       (if (char? c1)
+           (if (char? c2)
+               ($char= c1 c2)
+               (err c2))
+           (err c1))]
+      [(c1 c2 c3)
+       (if (char? c1)
+           (if (char? c2)
+               (if (char? c3)
+                   (and ($char= c1 c2)
+                        ($char= c2 c3))
+                   (err c3))
+               (err c2))
+           (err c1))]
+      [(c1 . c*)
+       (if (char? c1)
+           (let f ([c* c*])
+             (or (null? c*) 
+                 (let ([c2 ($car c*)])
+                   (if (char? c2)
+                       (if ($char= c1 c2)
+                           (f ($cdr c*))
+                           (let g ([c* ($cdr c*)])
+                             (if (null? c*)
+                                 #f
+                                 (if (char? ($car c*))
+                                     (g ($cdr c*))
+                                     (err ($car c*))))))
+                       (err c2)))))
+           (err c1))])))
+
+
+(primitive-set! 'char<?
+  (let ()
+    (define (err x)
+      (error 'char<? "~s is not a character" x))
+    (case-lambda
+      [(c1 c2)
+       (if (char? c1)
+           (if (char? c2)
+               ($char< c1 c2)
+               (err c2))
+           (err c1))]
+      [(c1 c2 c3)
+       (if (char? c1)
+           (if (char? c2)
+               (if (char? c3)
+                   (and ($char< c1 c2)
+                        ($char< c2 c3))
+                   (err c3))
+               (err c2))
+           (err c1))]
+      [(c1 . c*)
+       (if (char? c1)
+           (let f ([c1 c1] [c* c*])
+             (or (null? c*) 
+                 (let ([c2 ($car c*)])
+                   (if (char? c2)
+                       (if ($char< c1 c2)
+                           (f c2 ($cdr c*))
+                           (let g ([c* ($cdr c*)])
+                             (if (null? c*)
+                                 #f
+                                 (if (char? ($car c*))
+                                     (g ($cdr c*))
+                                     (err ($car c*))))))
+                       (err c2)))))
+           (err c1))])))
+
+(primitive-set! 'char<=?
+  (let ()
+    (define (err x)
+      (error 'char<=? "~s is not a character" x))
+    (case-lambda
+      [(c1 c2)
+       (if (char? c1)
+           (if (char? c2)
+               ($char<= c1 c2)
+               (err c2))
+           (err c1))]
+      [(c1 c2 c3)
+       (if (char? c1)
+           (if (char? c2)
+               (if (char? c3)
+                   (and ($char<= c1 c2)
+                        ($char<= c2 c3))
+                   (err c3))
+               (err c2))
+           (err c1))]
+      [(c1 . c*)
+       (if (char? c1)
+           (let f ([c1 c1] [c* c*])
+             (or (null? c*) 
+                 (let ([c2 ($car c*)])
+                   (if (char? c2)
+                       (if ($char<= c1 c2)
+                           (f c2 ($cdr c*))
+                           (let g ([c* ($cdr c*)])
+                             (if (null? c*)
+                                 #f
+                                 (if (char? ($car c*))
+                                     (g ($cdr c*))
+                                     (err ($car c*))))))
+                       (err c2)))))
+           (err c1))])))
+
+(primitive-set! 'char>?
+  (let ()
+    (define (err x)
+      (error 'char>? "~s is not a character" x))
+    (case-lambda
+      [(c1 c2)
+       (if (char? c1)
+           (if (char? c2)
+               ($char> c1 c2)
+               (err c2))
+           (err c1))]
+      [(c1 c2 c3)
+       (if (char? c1)
+           (if (char? c2)
+               (if (char? c3)
+                   (and ($char> c1 c2)
+                        ($char> c2 c3))
+                   (err c3))
+               (err c2))
+           (err c1))]
+      [(c1 . c*)
+       (if (char? c1)
+           (let f ([c1 c1] [c* c*])
+             (or (null? c*) 
+                 (let ([c2 ($car c*)])
+                   (if (char? c2)
+                       (if ($char> c1 c2)
+                           (f c2 ($cdr c*))
+                           (let g ([c* ($cdr c*)])
+                             (if (null? c*)
+                                 #f
+                                 (if (char? ($car c*))
+                                     (g ($cdr c*))
+                                     (err ($car c*))))))
+                       (err c2)))))
+           (err c1))])))
+
+(primitive-set! 'char>=?
+  (let ()
+    (define (err x)
+      (error 'char>=? "~s is not a character" x))
+    (case-lambda
+      [(c1 c2)
+       (if (char? c1)
+           (if (char? c2)
+               ($char>= c1 c2)
+               (err c2))
+           (err c1))]
+      [(c1 c2 c3)
+       (if (char? c1)
+           (if (char? c2)
+               (if (char? c3)
+                   (and ($char>= c1 c2)
+                        ($char>= c2 c3))
+                   (err c3))
+               (err c2))
+           (err c1))]
+      [(c1 . c*)
+       (if (char? c1)
+           (let f ([c1 c1] [c* c*])
+             (or (null? c*) 
+                 (let ([c2 ($car c*)])
+                   (if (char? c2)
+                       (if ($char>= c1 c2)
+                           (f c2 ($cdr c*))
+                           (let g ([c* ($cdr c*)])
+                             (if (null? c*)
+                                 #f
+                                 (if (char? ($car c*))
+                                     (g ($cdr c*))
+                                     (err ($car c*))))))
+                       (err c2)))))
+           (err c1))])))
+
+
+(primitive-set! 'cons (lambda (x y) (cons x y)))
+
+(primitive-set! 'eq? (lambda (x y) (eq? x y)))
+
+(primitive-set! 'set-car!
+  (lambda (x y) 
+    (unless (pair? x)
+      (error 'set-car! "~s is not a pair" x))
+    ($set-car! x y)))
+
+(primitive-set! 'set-cdr! 
+  (lambda (x y)
+    (unless (pair? x)
+      (error 'set-cdr! "~s is not a pair" x))
+    ($set-cdr! x y)))
+
+(primitive-set! 'vector-ref 
+  (lambda (v i)
+    (unless (vector? v)
+      (error 'vector-ref "~s is not a vector" v))
+    (unless (fixnum? i)
+      (error 'vector-ref "~s is not a valid index" i))
+    (unless (and ($fx< i ($vector-length v))
+                 ($fx<= 0 i))
+      (error 'vector-ref "index ~s is out of range for ~s" i v))
+    ($vector-ref v i)))
+
+(primitive-set! 'string-ref 
+  (lambda (s i) 
+    (unless (string? s) 
+      (error 'string-ref "~s is not a string" s))
+    (unless (fixnum? i)
+      (error 'string-ref "~s is not a valid index" i))
+    (unless (and ($fx< i ($string-length s))
+                 ($fx<= 0 i))
+      (error 'string-ref "index ~s is out of range for ~s" i s))
+    ($string-ref s i)))
+
+(primitive-set! 'vector-set! 
+  (lambda (v i c) 
+    (unless (vector? v) 
+      (error 'vector-set! "~s is not a vector" v))
+    (unless (fixnum? i)
+      (error 'vector-set! "~s is not a valid index" i))
+    (unless (and ($fx< i ($vector-length v))
+                 ($fx<= 0 i))
+      (error 'vector-set! "index ~s is out of range for ~s" i v))
+    ($vector-set! v i c)))
+
+
+(primitive-set! 'string-set! 
+  (lambda (s i c) 
+    (unless (string? s) 
+      (error 'string-set! "~s is not a string" s))
+    (unless (fixnum? i)
+      (error 'string-set! "~s is not a valid index" i))
+    (unless (and ($fx< i ($string-length s))
+                 ($fx>= i 0))
+      (error 'string-set! "index ~s is out of range for ~s" i s))
+    (unless (char? c)
+      (error 'string-set! "~s is not a character" c))
+    ($string-set! s i c)))
+
+(primitive-set! 'vector
+  ;;; FIXME: add case-lambda
+  (letrec ([length
+            (lambda (ls n)
+              (cond
+               [(null? ls) n]
+               [else (length ($cdr ls) ($fx+ n 1))]))]
+           [loop 
+            (lambda (v ls i n)
+              (cond
+               [($fx= i n) v]
+               [else 
+                ($vector-set! v i ($car ls))
+                (loop v ($cdr ls) ($fx+ i 1) n)]))])
+     (lambda ls
+       (let ([n (length ls 0)])
+         (let ([v (make-vector n)])
+           (loop v ls 0 n))))))
+
+(primitive-set! 'string
+  ;;; FIXME: add case-lambda
+  (letrec ([length
+            (lambda (ls n)
+              (cond
+               [(null? ls) n]
+               [(char? ($car ls)) (length ($cdr ls) ($fx+ n 1))]
+               [else (error 'string "~s is not a character" ($car ls))]))]
+           [loop 
+            (lambda (s ls i n)
+              (cond
+               [($fx= i n) s]
+               [else 
+                ($string-set! s i ($car ls))
+                (loop s ($cdr ls) ($fx+ i 1) n)]))])
+     (lambda ls
+       (let ([n (length ls 0)])
+         (let ([s (make-string n)])
+           (loop s ls 0 n))))))
+ 
+(primitive-set! 'list?
+  (letrec ([race
+            (lambda (h t)
+             (if (pair? h)
+                 (let ([h ($cdr h)])
+                    (if (pair? h)
+                        (and (not (eq? h t))
+                             (race ($cdr h) ($cdr t)))
+                        (null? h)))
+                 (null? h)))])
+     (lambda (x) (race x x))))
+
+
+
+(primitive-set! 'reverse
+  (letrec ([race
+            (lambda (h t ls ac)
+             (if (pair? h)
+                 (let ([h ($cdr h)] [ac (cons ($car h) ac)])
+                    (if (pair? h)
+                        (if (not (eq? h t))
+                            (race ($cdr h) ($cdr t) ls (cons ($car h) ac))
+                            (error 'reverse "~s is a circular list" ls))
+                        (if (null? h)
+                            ac
+                            (error 'reverse "~s is not a proper list" ls))))
+                 (if (null? h)
+                     ac
+                     (error 'reverse "~s is not a proper list" ls))))])
+     (lambda (x)
+       (race x x x '()))))
+
+(primitive-set! 'memq
+  (letrec ([race
+            (lambda (h t ls x)
+               (if (pair? h)
+                   (if (eq? ($car h) x)
+                       h
+                       (let ([h ($cdr h)])
+                         (if (pair? h)
+                             (if (eq? ($car h) x)
+                                 h
+                                 (if (not (eq? h t))
+                                     (race ($cdr h) ($cdr t) ls x)
+                                     (error 'memq "circular list ~s" ls)))
+                             (if (null? h)
+                                 '#f
+                                 (error 'memq "~s is not a proper list" ls)))))
+                   (if (null? h)
+                       '#f
+                       (error 'memq "~s is not a proper list" ls))))])
+     (lambda (x ls)
+       (race ls ls ls x))))
+
+(primitive-set! 'vector-memq
+  (lambda (x v)
+    (if (vector? v)
+        (let f ([x x] [v v] [n ($vector-length v)] [i 0])
+          (and ($fx< i n)
+               (or (eq? x ($vector-ref v i))
+                   (f x v n ($fxadd1 i)))))
+        (error 'vector-memq "~s is not a vector" v))))
+
+(primitive-set! 'memv memq)
+(primitive-set! 'vector-memv vector-memq)
+ 
+(primitive-set! 'list->string
+  (letrec ([race
+            (lambda (h t ls n)
+             (if (pair? h)
+                 (let ([h ($cdr h)])
+                    (if (pair? h)
+                        (if (not (eq? h t))
+                            (race ($cdr h) ($cdr t) ls ($fx+ n 2))
+                            (error 'reverse "circular list ~s" ls))
+                        (if (null? h)
+                            ($fx+ n 1)
+                            (error 'reverse "~s is not a proper list" ls))))
+                 (if (null? h)
+                     n
+                     (error 'reverse "~s is not a proper list" ls))))]
+            [fill
+             (lambda (s i ls)
+               (cond
+                 [(null? ls) s]
+                 [else
+                  (let ([c ($car ls)])
+                    (unless (char? c)
+                      (error 'list->string "~s is not a character" c))
+                    ($string-set! s i c)
+                    (fill s ($fxadd1 i) (cdr ls)))]))])
+     (lambda (ls)
+       (let ([n (race ls ls ls 0)])
+         (let ([s ($make-string n)])
+           (fill s 0 ls))))))
+
+(primitive-set! 'length
+  (letrec ([race
+            (lambda (h t ls n)
+             (if (pair? h)
+                 (let ([h ($cdr h)])
+                    (if (pair? h)
+                        (if (not (eq? h t))
+                            (race ($cdr h) ($cdr t) ls ($fx+ n 2))
+                            (error 'length "circular list ~s" ls))
+                        (if (null? h)
+                            ($fx+ n 1)
+                            (error 'length "~s is not a proper list" ls))))
+                 (if (null? h)
+                     n
+                     (error 'length "~s is not a proper list" ls))))])
+     (lambda (ls)
+       (race ls ls ls 0))))
+
+
+(primitive-set! 'list-ref
+  (lambda (list index)
+    (define f
+      (lambda (ls i)
+        (cond
+          [($fxzero? i) 
+           (if (pair? ls)
+               ($car ls)
+               (error 'list-ref "index ~s is out of range for ~s" index list))]
+          [(pair? ls)
+           (f ($cdr ls) ($fxsub1 i))]
+          [(null? ls) 
+           (error 'list-rec "index ~s is out of range for ~s" index list)]
+          [else (error 'list-ref "~s is not a list" list)])))
+    (unless (and (fixnum? index) ($fx>= index 0))
+      (error 'list-ref "~s is not a valid index" index))
+    (f list index)))
+
+  
+
+;(primitive-set! 'apply
+;  (letrec ([fix
+;            (lambda (arg arg*)
+;              (cond
+;               [(null? arg*) 
+;                (if (list? arg)
+;                    arg
+;                    (error 'apply "last arg is not a list"))]
+;               [else
+;                (cons arg (fix ($car arg*) ($cdr arg*)))]))])
+;    (lambda (f arg . arg*)
+;      (unless (procedure? f)
+;        (error 'apply "APPLY ~s ~s ~s" f arg arg*))
+;      ($apply f (fix arg arg*)))))
+;
+
+;(primitive-set! 'apply
+;  (letrec ([fix
+;            (lambda (arg arg*)
+;              (cond
+;               [(null? arg*) 
+;                (if (list? arg)
+;                    arg
+;                    (error 'apply "last arg is not a list"))]
+;               [else
+;                (cons arg (fix ($car arg*) ($cdr arg*)))]))])
+;    (lambda (f arg . arg*)
+;      (unless (procedure? f)
+;        (error 'apply "APPLY ~s ~s ~s" f arg arg*))
+;      (let ([args (fix arg arg*)])
+;        ($apply f args)))))
+
+(primitive-set! 'apply
+  (let ()
+    (define (err f ls)
+      (if (procedure? f)
+          (error 'apply "not a list")
+          (error 'apply "~s is not a procedure" f)))
+    (define (fixandgo f a0 a1 ls p d)
+      (cond
+        [(null? ($cdr d))
+         (let ([last ($car d)])
+           ($set-cdr! p last)
+           (if (and (procedure? f) (list? last))
+               ($apply f a0 a1 ls)
+               (err f last)))]
+        [else (fixandgo f a0 a1 ls d ($cdr d))]))
+    (define apply
+      (case-lambda
+        [(f ls) 
+         (if (and (procedure? f) (list? ls))
+             ($apply f ls)
+             (err f ls))]
+        [(f a0 ls)
+         (if (and (procedure? f) (list? ls))
+             ($apply f a0 ls)
+             (err f ls))]
+        [(f a0 a1 ls)
+         (if (and (procedure? f) (list? ls))
+             ($apply f a0 a1 ls)
+             (err f ls))]
+        [(f a0 a1 . ls)
+         (fixandgo f a0 a1 ls ls ($cdr ls))]))
+    apply))
+
+
+             
+
+   
+(primitive-set! 'assq
+  (letrec ([race
+            (lambda (x h t ls)
+              (if (pair? h)
+                  (let ([a ($car h)] [h ($cdr h)])
+                     (if (pair? a)
+                         (if (eq? ($car a) x)
+                             a
+                             (if (pair? h)
+                                 (if (not (eq? h t))
+                                     (let ([a ($car h)])
+                                        (if (pair? a)
+                                            (if (eq? ($car a) x)
+                                                a
+                                                (race x ($cdr h) ($cdr t) ls))
+                                            (error 'assq "malformed alist ~s"
+                                                   ls)))
+                                     (error 'assq "circular list ~s" ls))
+                                 (if (null? h)
+                                     #f
+                                     (error 'assq "~s is not a proper list" ls))))
+                         (error 'assq "malformed alist ~s" ls)))
+                  (if (null? h)
+                      #f
+                      (error 'assq "~s is not a proper list" ls))))])
+     (lambda (x ls) 
+       (race x ls ls ls))))
+
+(primitive-set! 'string->symbol
+  (lambda (x)
+    (unless (string? x) 
+      (error 'string->symbol "~s is not a string" x))
+    (foreign-call "ik_intern_string" x)))
+  
+(primitive-set! 'oblist
+  (lambda ()
+    (foreign-call "ik_oblist")))
+
+(primitive-set! 'gensym
+  (case-lambda
+    [() ($make-symbol #f)]
+    [(s) 
+     (if (string? s)
+         ($make-symbol s)
+         (error 'gensym "~s is not a string" s))]))
+
+(primitive-set! 'putprop
+  (lambda (x k v)
+    (unless (symbol? x) (error 'putprop "~s is not a symbol" x))
+    (unless (symbol? k) (error 'putprop "~s is not a symbol" k))
+    (let ([p ($symbol-plist x)])
+      (cond
+        [(assq k p) => (lambda (x) (set-cdr! x v))]
+        [else 
+         ($set-symbol-plist! x (cons (cons k v) p))]))))
+
+(primitive-set! 'getprop
+  (lambda (x k)
+    (unless (symbol? x) (error 'getprop "~s is not a symbol" x))
+    (unless (symbol? k) (error 'getprop "~s is not a symbol" k))
+    (let ([p ($symbol-plist x)])
+      (cond
+        [(assq k p) => cdr]
+        [else #f]))))
+
+(primitive-set! 'remprop
+  (lambda (x k)
+    (unless (symbol? x) (error 'remprop "~s is not a symbol" x))
+    (unless (symbol? k) (error 'remprop "~s is not a symbol" k))
+    (let ([p ($symbol-plist x)])
+      (unless (null? p)
+        (let ([a ($car p)])
+          (cond
+            [(eq? ($car a) k) ($set-symbol-plist! x ($cdr p))]
+            [else 
+             (let f ([q p] [p ($cdr p)])
+               (unless (null? p)
+                 (let ([a ($car p)])
+                   (cond
+                     [(eq? ($car a) k)
+                      ($set-cdr! q ($cdr p))]
+                     [else 
+                      (f p ($cdr p))]))))]))))))
+
+(primitive-set! 'property-list
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'property-list "~s is not a symbol" x))
+    (letrec ([f 
+              (lambda (ls ac)
+                (cond
+                  [(null? ls) ac]
+                  [else
+                   (let ([a ($car ls)])
+                     (f ($cdr ls) 
+                        (cons ($car a) (cons ($cdr a) ac))))]))])
+      (f ($symbol-plist x) '()))))
+
+
+;;X (primitive-set! 'make-parameter
+;;X   (letrec ([make-param-no-guard
+;;X             (lambda (x)
+;;X               (lambda args
+;;X                 (if (null? args)
+;;X                     x
+;;X                     (if (null? ($cdr args))
+;;X                         (set! x ($car args))
+;;X                         (error #f "too many arguments to parameter")))))]
+;;X            [make-param-with-guard
+;;X             (lambda (x g)
+;;X               (let ([f
+;;X                      (lambda args
+;;X                        (if (null? args)
+;;X                            x
+;;X                            (if (null? ($cdr args))
+;;X                                (set! x (g ($car args)))
+;;X                                (error #f "too many arguments to parameter"))))])
+;;X                (if (procedure? g)
+;;X                    (begin (set! x (g x)) f)
+;;X                    (error 'make-parameter "not a procedure ~s" g))))])
+;;X     (lambda args
+;;X        (if (pair? args)
+;;X            (let ([x ($car args)] [args ($cdr args)])
+;;X              (if (null? args)
+;;X                  (make-param-no-guard x)
+;;X                  (let ([g ($car args)])
+;;X                    (if (null? ($cdr args))
+;;X                        (make-param-with-guard x g)
+;;X                        (error 'make-parameter "too many arguments")))))
+;;X            (error 'make-parameter "insufficient arguments")))))
+;;X 
+
+(primitive-set! 'make-parameter
+  (case-lambda
+    [(x) 
+     (case-lambda
+       [() x]
+       [(v) (set! x v)])]
+    [(x guard)
+     (unless (procedure? guard)
+       (error 'make-parameter "~s is not a procedure" guard))
+     (set! x (guard x))
+     (case-lambda
+       [() x]
+       [(v) (set! x (guard v))])]))
+
+(let ()
+   (define vector-loop
+     (lambda (x y i n)
+       (or ($fx= i n)
+           (and (equal? ($vector-ref x i) ($vector-ref y i))
+                (vector-loop x y ($fxadd1 i) n)))))
+   (define string-loop
+     (lambda (x y i n)
+       (or ($fx= i n)
+           (and ($char= ($string-ref x i) ($string-ref y i))
+                (string-loop x y ($fxadd1 i) n)))))
+   (define equal?
+     (lambda (x y)
+       (cond
+         [(eq? x y) #t]
+         [(pair? x) 
+          (and (pair? y)
+               (equal? ($car x) ($car y))
+               (equal? ($cdr x) ($cdr y)))]
+         [(vector? x)
+          (and (vector? y)
+               (let ([n ($vector-length x)])
+                 (and ($fx= n ($vector-length y))
+                      (vector-loop x y 0 n))))]
+         [(string? x)
+          (and (string? y)
+               (let ([n ($string-length x)])
+                 (and ($fx= n ($string-length y))
+                      (string-loop x y 0 n))))]
+         [else #f])))
+   (primitive-set! 'equal? equal?))
+
+
+(let ()
+  (define who 'map)
+  (define len
+    (lambda (h t n)
+      (if (pair? h)
+          (let ([h ($cdr h)])
+            (if (pair? h)
+                (if (eq? h t)
+                    (error who "circular list")
+                    (len ($cdr h) ($cdr t) ($fx+ n 2)))
+                (if (null? h)
+                    ($fxadd1 n)
+                    (error who "improper list"))))
+          (if (null? h)
+              n
+              (error who "improper list")))))
+  (define map1
+    (lambda (f a d n)
+      (cond
+        [(pair? d)
+         (if ($fxzero? n)
+             (error who "list was altered!")
+             (cons (f a)
+                   (map1 f ($car d) ($cdr d) ($fxsub1 n))))]
+        [(null? d)
+         (if ($fxzero? n)
+             (cons (f a) '())
+             (error who "list was altered"))]
+        [else (error who "list was altered")])))
+  (define map2
+    (lambda (f a1 a2 d1 d2 n)
+      (cond
+        [(pair? d1)
+         (cond
+           [(pair? d2)
+            (if ($fxzero? n)
+                (error who "list was altered")
+                (cons (f a1 a2) 
+                      (map2 f
+                            ($car d1) ($car d2)
+                            ($cdr d1) ($cdr d2)
+                            ($fxsub1 n))))]
+           [else (error who "length mismatch")])]
+        [(null? d1)
+         (cond
+           [(null? d2)
+            (if ($fxzero? n)
+                (cons (f a1 a2) '())
+                (error who "list was altered"))]
+           [else (error who "length mismatch")])]
+        [else (error who "list was altered")])))
+  (define cars
+    (lambda (ls*)
+      (cond
+        [(null? ls*) '()]
+        [else
+         (let ([a (car ls*)])
+           (cond
+             [(pair? a) 
+              (cons (car a) (cars (cdr ls*)))]
+             [else 
+              (error 'map "length mismatch")]))])))
+  (define cdrs
+    (lambda (ls*)
+      (cond
+        [(null? ls*) '()]
+        [else
+         (let ([a (car ls*)])
+           (cond
+             [(pair? a) 
+              (cons (cdr a) (cdrs (cdr ls*)))]
+             [else 
+              (error 'map "length mismatch")]))])))
+  (define mapm
+    (lambda (f ls ls* n)
+      (cond
+        [(null? ls)
+         (if (andmap null? ls*)
+             (if (fxzero? n)
+                 '()
+                 (error 'map "lists were mutated during operation"))
+             (error 'map "length mismatch"))]
+        [(fxzero? n)
+         (error 'map "lists were mutated during operation")]
+        [else
+         (cons
+           (apply f (car ls) (cars ls*))
+           (mapm f (cdr ls) (cdrs ls*) (fxsub1 n)))])))
+  (primitive-set! 'map
+     (case-lambda
+       [(f ls) 
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (let ([d ($cdr ls)])
+             (map1 f ($car ls) d (len d d 0)))]
+          [(null? ls) '()]
+          [else (error who "improper list")])]
+       [(f ls ls2)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (if (pair? ls2)
+               (let ([d ($cdr ls)])
+                 (map2 f ($car ls) ($car ls2) d ($cdr ls2) (len d d 0)))
+               (error who "length mismatch"))]
+          [(null? ls)
+           (if (null? ls2)
+               '()
+               (error who "length mismatch"))]
+          [else (error who "not a list")])]
+       [(f ls . ls*)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (let ([n (len ls ls 0)])
+             (mapm f ls ls* n))]
+          [(null? ls)
+           (if (andmap null? ls*)
+               '()
+               (error who "length mismatch"))])])))
+
+
+(let ()
+  (define who 'for-each)
+  (define len
+    (lambda (h t n)
+      (if (pair? h)
+          (let ([h ($cdr h)])
+            (if (pair? h)
+                (if (eq? h t)
+                    (error who "circular list")
+                    (len ($cdr h) ($cdr t) ($fx+ n 2)))
+                (if (null? h)
+                    ($fxadd1 n)
+                    (error who "improper list"))))
+          (if (null? h)
+              n
+              (error who "improper list")))))
+  (define for-each1
+    (lambda (f a d n)
+      (cond
+        [(pair? d)
+         (if ($fxzero? n)
+             (error who "list was altered!")
+             (begin 
+               (f a)
+               (for-each1 f ($car d) ($cdr d) ($fxsub1 n))))]
+        [(null? d)
+         (if ($fxzero? n)
+             (f a)
+             (error who "list was altered"))]
+        [else (error who "list was altered")])))
+  (define for-each2
+    (lambda (f a1 a2 d1 d2 n)
+      (cond
+        [(pair? d1)
+         (cond
+           [(pair? d2)
+            (if ($fxzero? n)
+                (error who "list was altered")
+                (begin
+                  (f a1 a2) 
+                  (for-each2 f
+                    ($car d1) ($car d2)
+                    ($cdr d1) ($cdr d2)
+                    ($fxsub1 n))))]
+           [else (error who "length mismatch")])]
+        [(null? d1)
+         (cond
+           [(null? d2)
+            (if ($fxzero? n)
+                (f a1 a2)
+                (error who "list was altered"))]
+           [else (error who "length mismatch")])]
+        [else (error who "list was altered")])))
+  (primitive-set! 'for-each
+     (case-lambda
+       [(f ls)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (let ([d ($cdr ls)])
+             (for-each1 f ($car ls) d (len d d 0)))]
+          [(null? ls) (void)]
+          [else (error who "improper list")])]
+       [(f ls ls2)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (if (pair? ls2)
+               (let ([d ($cdr ls)])
+                 (for-each2 f
+                    ($car ls) ($car ls2) d ($cdr ls2) (len d d 0)))
+               (error who "length mismatch"))]
+          [(null? ls)
+           (if (null? ls2)
+               (void)
+               (error who "length mismatch"))]
+          [else (error who "not a list")])]
+       [_ (error who "vararg not supported yet")])))
+
+
+
+(let ()
+  (define who 'andmap)
+  (define len
+    (lambda (h t n)
+      (if (pair? h)
+          (let ([h ($cdr h)])
+            (if (pair? h)
+                (if (eq? h t)
+                    (error who "circular list")
+                    (len ($cdr h) ($cdr t) ($fx+ n 2)))
+                (if (null? h)
+                    ($fxadd1 n)
+                    (error who "improper list"))))
+          (if (null? h)
+              n
+              (error who "improper list")))))
+  (define andmap1
+    (lambda (f a d n)
+      (cond
+        [(pair? d)
+         (if ($fxzero? n)
+             (error who "list was altered!")
+             (and (f a)
+                  (andmap1 f ($car d) ($cdr d) ($fxsub1 n))))]
+        [(null? d)
+         (if ($fxzero? n)
+             (f a)
+             (error who "list was altered"))]
+        [else (error who "list was altered")])))
+  (primitive-set! 'andmap
+     (case-lambda
+       [(f ls)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (let ([d ($cdr ls)])
+             (andmap1 f ($car ls) d (len d d 0)))]
+          [(null? ls) #t]
+          [else (error who "improper list")])]
+       [_ (error who "vararg not supported yet")])))
+
+
+(let ()
+  (define who 'ormap)
+  (define len
+    (lambda (h t n)
+      (if (pair? h)
+          (let ([h ($cdr h)])
+            (if (pair? h)
+                (if (eq? h t)
+                    (error who "circular list")
+                    (len ($cdr h) ($cdr t) ($fx+ n 2)))
+                (if (null? h)
+                    ($fxadd1 n)
+                    (error who "improper list"))))
+          (if (null? h)
+              n
+              (error who "improper list")))))
+  (define ormap1
+    (lambda (f a d n)
+      (cond
+        [(pair? d)
+         (if ($fxzero? n)
+             (error who "list was altered!")
+             (or (f a)
+                 (ormap1 f ($car d) ($cdr d) ($fxsub1 n))))]
+        [(null? d)
+         (if ($fxzero? n)
+             (f a)
+             (error who "list was altered"))]
+        [else (error who "list was altered")])))
+  (primitive-set! 'ormap
+     (case-lambda
+       [(f ls)
+        (unless (procedure? f)
+          (error who "~s is not a procedure" f))
+        (cond
+          [(pair? ls)
+           (let ([d ($cdr ls)])
+             (ormap1 f ($car ls) d (len d d 0)))]
+          [(null? ls) #f]
+          [else (error who "improper list")])]
+       [_ (error who "vararg not supported yet")])))
+
+
+
+
+(let ()
+  (define reverse
+    (lambda (h t ls ac)
+      (if (pair? h)
+          (let ([h ($cdr h)] [a1 ($car h)])
+             (if (pair? h)
+                 (if (not (eq? h t))
+                     (let ([a2 ($car h)])
+                       (reverse ($cdr h) ($cdr t) ls (cons a2 (cons a1 ac))))
+                     (error 'append "circular list ~s" ls))
+                 (if (null? h)
+                     (cons a1 ac)
+                     (error 'append "~s is not a proper list" ls))))
+          (if (null? h)
+              ac 
+              (error 'append "~s is not a proper list" ls)))))
+  (define revcons
+    (lambda (ls ac)
+      (cond
+        [(null? ls) ac]
+        [else
+         (revcons ($cdr ls) (cons ($car ls) ac))])))
+  (define append
+    (lambda (ls ls*)
+      (cond
+        [(null? ls*) ls]
+        [else 
+         (revcons (reverse ls ls ls '())
+            (append ($car ls*) ($cdr ls*)))])))
+  (primitive-set! 'append
+    (lambda (ls . ls*)
+      (append ls ls*))))
+
+
+(primitive-set! 'list->vector
+  (letrec ([race
+            (lambda (h t ls n)
+             (if (pair? h)
+                 (let ([h ($cdr h)])
+                    (if (pair? h)
+                        (if (not (eq? h t))
+                            (race ($cdr h) ($cdr t) ls ($fx+ n 2))
+                            (error 'list->vector "circular list ~s" ls))
+                        (if (null? h)
+                            ($fx+ n 1)
+                            (error 'list->vector "~s is not a proper list" ls))))
+                 (if (null? h)
+                     n
+                     (error 'list->vector "~s is not a proper list" ls))))]
+            [fill
+             (lambda (v i ls)
+               (cond
+                 [(null? ls) v]
+                 [else
+                  (let ([c ($car ls)])
+                    ($vector-set! v i c)
+                    (fill v ($fxadd1 i) (cdr ls)))]))])
+     (lambda (ls)
+       (let ([n (race ls ls ls 0)])
+         (let ([v (make-vector n)])
+           (fill v 0 ls))))))
+
+
+(let ()
+  (define f
+    (lambda (v i ls)
+      (cond
+        [($fx< i 0) ls]
+        [else
+         (f v ($fxsub1 i) (cons ($vector-ref v i) ls))])))
+  (primitive-set! 'vector->list
+    (lambda (v)
+      (if (vector? v)
+          (let ([n ($vector-length v)])
+            (if ($fxzero? n)
+                '()
+                (f v ($fxsub1 n) '())))
+          (error 'vector->list "~s is not a vector" v)))))
+  
+(let ()
+  (define f
+    (lambda (n fill ls)
+      (cond
+        [($fxzero? n) ls]
+        [else
+         (f ($fxsub1 n) fill (cons fill ls))])))
+  (primitive-set! 'make-list
+    (case-lambda
+      [(n)
+       (if (and (fixnum? n) ($fx>= n 0))
+           (f n (void) '())
+           (error 'make-list "~s is not a valid length" n))]
+      [(n fill)
+       (if (and (fixnum? n) ($fx>= n 0))
+           (f n fill '())
+           (error 'make-list "~s is not a valid length" n))])))
+
+(primitive-set! 'list (lambda x x))
+
+(primitive-set! 'uuid
+   (lambda ()
+     (let ([s (make-string 16)])
+       (or (foreign-call "ik_uuid" s)
+           (error 'uuid "failed!")))))
+
+(primitive-set! 'gensym->unique-string
+  (lambda (x)
+    (unless (symbol? x)
+      (error 'gensym->unique-string "~s is not a gensym" x))
+    (let ([us ($symbol-unique-string x)])
+      (cond
+        [(string? us) us]
+        [(eq? us #t) 
+         (error 'gensym->unique-string "~s is not a gensym" x)]
+        [else
+         (let ([id (uuid)])
+           ($set-symbol-unique-string! x id)
+           id)]))))
+
+(primitive-set! 'gensym-prefix
+  (make-parameter
+    "g"
+    (lambda (x)
+      (unless (string? x)
+        (error 'gensym-prefix "~s is not a string" x))
+      x)))
+
+(primitive-set! 'gensym-count
+  (make-parameter
+    0
+    (lambda (x)
+      (unless (and (fixnum? x) ($fx>= x 0))
+        (error 'gensym-count "~s is not a valid count" x))
+      x)))
+
+(primitive-set! 'print-gensym
+  (make-parameter
+    #t
+    (lambda (x)
+      (unless (boolean? x) 
+        (error 'print-gensym "~s is not a boolean" x))
+      x)))
+
+;; X (primitive-set! 'make-hash-table
+;; X   (lambda ()
+;; X     (make-hash-table)))
+;; X 
+;; X (primitive-set! 'hash-table?
+;; X   (lambda (x)
+;; X     (hash-table? x)))
+;; X 
+;; X (primitive-set! 'get-hash-table
+;; X   (lambda (h k v)
+;; X     (foreign-call "ik_get_hash_table" h k v)))
+;; X 
+;; X (primitive-set! 'put-hash-table!
+;; X   (lambda (h k v)
+;; X     (foreign-call "ik_put_hash_table" h k v)))
+
+(primitive-set! 'bwp-object?
+  (lambda (x)
+    (bwp-object? x)))
+
+(primitive-set! 'weak-cons
+  (lambda (a d)
+    (foreign-call "ikrt_weak_cons" a d)))
+
+(primitive-set! 'weak-pair?
+  (lambda (x)
+    (and (pair? x)
+         (foreign-call "ikrt_is_weak_pair" x))))
+
+(primitive-set! 'pointer-value
+  (lambda (x)
+    (pointer-value x)))
+
+(primitive-set! 'date-string
+  (lambda ()
+    (let ([s (make-string 10)])
+      (foreign-call "ikrt_strftime" s "%F")
+      s)))
+
+(primitive-set! 'features
+  (lambda ()
+    (append (macros) (public-primitives) '())))
+
+(primitive-set! 'list*
+  (lambda (fst . rest)
+    (let f ([fst fst] [rest rest])
+      (cond
+        [(null? rest) fst]
+        [else 
+         (cons fst (f ($car rest) ($cdr rest)))]))))
+
diff --git a/src/libcore.fasl b/src/libcore.fasl
index b76f633..13bff9c 100644
Binary files a/src/libcore.fasl and b/src/libcore.fasl differ
diff --git a/src/libcxr.fasl b/src/libcxr.fasl
index d086bce..0405654 100644
Binary files a/src/libcxr.fasl and b/src/libcxr.fasl differ
diff --git a/src/libexpand.fasl b/src/libexpand.fasl
deleted file mode 100644
index dac116e..0000000
Binary files a/src/libexpand.fasl and /dev/null differ
diff --git a/src/libfasl-6.0.ss b/src/libfasl-6.0.ss
index 6e61fc5..3ed6c7d 100644
--- a/src/libfasl-6.0.ss
+++ b/src/libfasl-6.0.ss
@@ -1,4 +1,3 @@
-;;; not finished yet 
 
 ;;; FASL 
 ;;;
@@ -20,7 +19,10 @@
 ;;;   "V" + 4-bytes(n) + object ... : a vector of length n followed by n
 ;;;                                   objects
 ;;;   "S" + 4-bytes(n) + char ... : a string
-;;;   "M" + object + object : a symbol with name field and a unique-name field
+;;;   "M" + symbol-name : a symbol
+;;;   "G" + pretty-name + unique-name : a gensym
+;;;   "R" + rtd-name + rtd-symbol + field-count + field-names
+;;;   "{" + field-count + rtd + fields
 ;;;   ">" + 4-bytes(i) : mark the next object with index i
 ;;;   "<" + 4-bytes(i) : dereference the object marked with index i
 ;;;
@@ -41,7 +43,6 @@
       (write-char (integer->char (fxlogand (fxsra x 8) #xFF)) p)
       (write-char (integer->char (fxlogand (fxsra x 16) #xFF)) p)
       (write-char (integer->char (fxlogand (fxsra x 24) #xFF)) p)))
- 
 
   (define fasl-write-immediate
     (lambda (x p)
@@ -86,11 +87,11 @@
               (f x (fxadd1 i) n)]))]
         [(gensym? x)
          (write-char #\G p)
-         (do-write (gensym->unique-name x) p h
-           (do-write (symbol->string x) p h m))]
+         (fasl-write (gensym->unique-string x) p h
+           (fasl-write (symbol->string x) p h m))]
         [(symbol? x) 
          (write-char #\M p)
-         (do-write (symbol->string x) p h m)]
+         (fasl-write (symbol->string x) p h m)]
         [(code? x)
          (write-char #\X p)
          (let ([code-vec (code-code-vec x)]
@@ -132,6 +133,36 @@
                         (let ([m (fasl-write object p h m)])
                           (f (fx+ i 2) n m)))]
                      [else (error 'fasl-write "invalid reloc byte ~s" b)])))))]
+        [(record? x)
+         (let ([rtd (record-type-descriptor x)])
+           (cond
+             [(eq? rtd #%$base-rtd)
+              ;;; rtd record
+              (write-char #\R p)
+              (let ([names (record-type-field-names x)]
+                    [m 
+                     (fasl-write (record-type-symbol x) p h
+                       (fasl-write (record-type-name x) p h m))])
+                (write-int (length names) p)
+                (let f ([names names] [m m])
+                  (cond
+                    [(null? names) m]
+                    [else
+                     (f (cdr names)
+                        (fasl-write (car names) p h m))])))]
+             [else
+              ;;; non-rtd record
+              (write-char #\{ p)
+              (write-int (length (record-type-field-names rtd)) p)
+              (let f ([names (record-type-field-names rtd)] 
+                      [m (fasl-write rtd p h m)])
+                (cond
+                  [(null? names) m]
+                  [else
+                   (f (cdr names) 
+                      (fasl-write 
+                         ((record-field-accessor rtd (car names)) x)
+                         p h m))]))]))]
         [else (error 'fasl-write "~s is not fasl-writable" x)])))
   (define fasl-write 
     (lambda (x p h m)
@@ -153,7 +184,7 @@
               (write-char #\< p)
               (write-int (fx- 0 mark) p)
               m]))]
-        [else (error 'fasl-write "BUG: not in hash table")]))) 
+        [else (error 'fasl-write "BUG: not in hash table ~s" x)]))) 
   (define make-graph
     (lambda (x h)
       (unless (immediate? x)
@@ -172,7 +203,9 @@
                 (unless (fx= i n) 
                   (make-graph (vector-ref x i) h)
                   (f x (fxadd1 i) n)))]
-             [(symbol? x) (void)]
+             [(symbol? x) 
+              (make-graph (symbol->string x) h)
+              (when (gensym? x) (make-graph (gensym->unique-string x) h))]
              [(string? x) (void)]
              [(code? x) 
               (let ([x (code-reloc-vec x)])
@@ -188,6 +221,24 @@
                          (f (fx+ i 2) n)]
                         [else (error 'fasl-write "unrecognized reloc ~s" b)]
                         )))))]
+             [(record? x)
+              (when (eq? x #%$base-rtd) 
+                (error 'fasl-write "$base-rtd is not writable"))
+              (let ([rtd (record-type-descriptor x)])
+                (cond
+                  [(eq? rtd #%$base-rtd)
+                   ;;; this is an rtd
+                   (make-graph (record-type-name x) h)
+                   (make-graph (record-type-symbol x) h)
+                   (for-each (lambda (x) (make-graph x h))
+                     (record-type-field-names x))]
+                  [else
+                   ;;; this is a record
+                   (make-graph rtd h)
+                   (for-each 
+                     (lambda (name) 
+                       (make-graph ((record-field-accessor rtd name) x) h))
+                     (record-type-field-names rtd))]))]
              [else (error 'fasl-write "~s is not fasl-writable" x)])]))))
   (define do-fasl-write 
     (lambda (x port)
diff --git a/src/libfasl-6.6.ss b/src/libfasl-6.6.ss
new file mode 100644
index 0000000..2cab6ef
--- /dev/null
+++ b/src/libfasl-6.6.ss
@@ -0,0 +1,217 @@
+
+;;; FASL 
+;;;
+;;; A fasl object is a header followed by one or more objects followed by an
+;;; end-of-fasl marker
+;;;
+;;; The header is the string "#@IK01"
+;;; The end of fasl marker is "@"
+;;;
+;;; An object is either:
+;;;   "N" : denoting the empty list
+;;;   "T" : denoting #t
+;;;   "F" : denoting #f
+;;;   "E" : denoting the end of file object
+;;;   "U" : denoting the unspecified value
+;;;   "I" + 4-bytes : denoting a fixnum (in host byte order)
+;;;   "C" + 1-byte : denoting a character
+;;;   "P" + object1 + object2 : a pair
+;;;   "V" + 4-bytes(n) + object ... : a vector of length n followed by n
+;;;                                   objects
+;;;   "S" + 4-bytes(n) + char ... : a string
+;;;   "M" + symbol-name : a symbol
+;;;   "G" + pretty-name + unique-name : a gensym
+;;;   "R" + rtd-name + rtd-symbol + field-count + field-names
+;;;   "{" + field-count + rtd + fields
+;;;   ">" + 4-bytes(i) : mark the next object with index i
+;;;   "<" + 4-bytes(i) : dereference the object marked with index i
+;;;
+
+
+(let ()
+  (define write-fixnum 
+    (lambda (x p)
+      (unless (fixnum? x) (error 'write-fixnum "not a fixnum ~s" x))
+      (write-char (integer->char (fxsll (fxlogand x #x3F) 2)) p)
+      (write-char (integer->char (fxlogand (fxsra x 6) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 14) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 22) #xFF)) p)))
+  (define write-int 
+    (lambda (x p)
+      (unless (fixnum? x) (error 'write-int "not a fixnum ~s" x))
+      (write-char (integer->char (fxlogand x #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 8) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 16) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 24) #xFF)) p)))
+
+  (define fasl-write-immediate
+    (lambda (x p)
+      (cond
+        [(null? x) (write-char #\N p)]
+        [(fixnum? x) 
+         (write-char #\I p)
+         (write-fixnum x p)]
+        [(char? x)
+         (write-char #\C p)
+         (write-char x p)]
+        [(boolean? x)
+         (write-char (if x #\T #\F) p)]
+        [(eof-object? x) (write-char #\E p)]
+        [(eq? x (void)) (write-char #\U p)]
+        [else (error 'fasl-write "~s is not a fasl-writable immediate" x)])))
+
+  (define do-write
+    (lambda (x p h m)
+      (cond
+        [(pair? x)   
+         (write-char #\P p)
+         (fasl-write (cdr x) p h
+           (fasl-write (car x) p h m))]
+        [(vector? x)
+         (write-char #\V p)
+         (write-int (vector-length x) p)
+         (let f ([x x] [i 0] [n (vector-length x)] [m m])
+           (cond
+             [(fx= i n) m]
+             [else
+              (f x (fxadd1 i) n
+                 (fasl-write (vector-ref x i) p h m))]))]
+        [(string? x) 
+         (write-char #\S p)
+         (write-int (string-length x) p)
+         (let f ([x x] [i 0] [n (string-length x)])
+           (cond
+             [(fx= i n) m]
+             [else
+              (write-char (string-ref x i) p)
+              (f x (fxadd1 i) n)]))]
+        [(gensym? x)
+         (write-char #\G p)
+         (fasl-write (gensym->unique-string x) p h
+           (fasl-write (symbol->string x) p h m))]
+        [(symbol? x) 
+         (write-char #\M p)
+         (fasl-write (symbol->string x) p h m)]
+        [(code? x)
+         (write-char #\x p)
+         (write-int (code-size x) p)
+         (write-int (code-closure-size x) p)
+         (let f ([i 0] [n (code-size x)])
+           (unless (fx= i n)
+             (write-char (integer->char (code-ref x i)) p)
+             (f (fxadd1 i) n)))
+         (fasl-write (code-reloc-vector x) p h m)]
+        [(record? x)
+         (let ([rtd (record-type-descriptor x)])
+           (cond
+             [(eq? rtd #%$base-rtd)
+              ;;; rtd record
+              (write-char #\R p)
+              (let ([names (record-type-field-names x)]
+                    [m 
+                     (fasl-write (record-type-symbol x) p h
+                       (fasl-write (record-type-name x) p h m))])
+                (write-int (length names) p)
+                (let f ([names names] [m m])
+                  (cond
+                    [(null? names) m]
+                    [else
+                     (f (cdr names)
+                        (fasl-write (car names) p h m))])))]
+             [else
+              ;;; non-rtd record
+              (write-char #\{ p)
+              (write-int (length (record-type-field-names rtd)) p)
+              (let f ([names (record-type-field-names rtd)] 
+                      [m (fasl-write rtd p h m)])
+                (cond
+                  [(null? names) m]
+                  [else
+                   (f (cdr names) 
+                      (fasl-write 
+                         ((record-field-accessor rtd (car names)) x)
+                         p h m))]))]))]
+        [else (error 'fasl-write "~s is not fasl-writable" x)])))
+  (define fasl-write 
+    (lambda (x p h m)
+      (cond
+        [(immediate? x) (fasl-write-immediate x p) m]
+        [(get-hash-table h x #f) =>
+         (lambda (mark)
+           (unless (fixnum? mark)
+             (error 'fasl-write "BUG: invalid mark ~s" mark))
+           (cond
+             [(fx= mark 0) ; singly referenced
+              (do-write x p h m)]
+             [(fx> mark 0) ; marked but not written
+              (put-hash-table! h x (fx- 0 m))
+              (write-char #\> p)
+              (write-int m p)
+              (do-write x p h (fxadd1 m))]
+             [else
+              (write-char #\< p)
+              (write-int (fx- 0 mark) p)
+              m]))]
+        [else (error 'fasl-write "BUG: not in hash table ~s" x)]))) 
+  (define make-graph
+    (lambda (x h)
+      (unless (immediate? x)
+        (cond
+          [(get-hash-table h x #f) =>
+           (lambda (i) 
+             (put-hash-table! h x (fxadd1 i)))]
+          [else
+           (put-hash-table! h x 0)
+           (cond
+             [(pair? x) 
+              (make-graph (car x) h)
+              (make-graph (cdr x) h)]
+             [(vector? x)
+              (let f ([x x] [i 0] [n (vector-length x)])
+                (unless (fx= i n) 
+                  (make-graph (vector-ref x i) h)
+                  (f x (fxadd1 i) n)))]
+             [(symbol? x) 
+              (make-graph (symbol->string x) h)
+              (when (gensym? x) (make-graph (gensym->unique-string x) h))]
+             [(string? x) (void)]
+             [(code? x) 
+              (make-graph (code-reloc-vector x) h)]
+             [(record? x)
+              (when (eq? x #%$base-rtd) 
+                (error 'fasl-write "$base-rtd is not writable"))
+              (let ([rtd (record-type-descriptor x)])
+                (cond
+                  [(eq? rtd #%$base-rtd)
+                   ;;; this is an rtd
+                   (make-graph (record-type-name x) h)
+                   (make-graph (record-type-symbol x) h)
+                   (for-each (lambda (x) (make-graph x h))
+                     (record-type-field-names x))]
+                  [else
+                   ;;; this is a record
+                   (make-graph rtd h)
+                   (for-each 
+                     (lambda (name) 
+                       (make-graph ((record-field-accessor rtd name) x) h))
+                     (record-type-field-names rtd))]))]
+             [else (error 'fasl-write "~s is not fasl-writable" x)])]))))
+  (define do-fasl-write 
+    (lambda (x port)
+      (let ([h (make-hash-table)])
+         (make-graph x h)
+         (write-char #\# port)
+         (write-char #\@ port)
+         (write-char #\I port)
+         (write-char #\K port)
+         (write-char #\0 port)
+         (write-char #\1 port)
+         (fasl-write x port h 1))))
+  (primitive-set! 'fasl-write
+     (case-lambda 
+       [(x) (do-fasl-write x (current-output-port))]
+       [(x port)
+        (unless (output-port? port)
+          (error 'fasl-write "~s is not an output port" port))
+        (do-fasl-write x port)])))
+
diff --git a/src/libfasl-6.7.ss b/src/libfasl-6.7.ss
new file mode 100644
index 0000000..6f1fe90
--- /dev/null
+++ b/src/libfasl-6.7.ss
@@ -0,0 +1,217 @@
+
+;;; FASL 
+;;;
+;;; A fasl object is a header followed by one or more objects followed by an
+;;; end-of-fasl marker
+;;;
+;;; The header is the string "#@IK01"
+;;; The end of fasl marker is "@"
+;;;
+;;; An object is either:
+;;;   "N" : denoting the empty list
+;;;   "T" : denoting #t
+;;;   "F" : denoting #f
+;;;   "E" : denoting the end of file object
+;;;   "U" : denoting the unspecified value
+;;;   "I" + 4-bytes : denoting a fixnum (in host byte order)
+;;;   "C" + 1-byte : denoting a character
+;;;   "P" + object1 + object2 : a pair
+;;;   "V" + 4-bytes(n) + object ... : a vector of length n followed by n
+;;;                                   objects
+;;;   "S" + 4-bytes(n) + char ... : a string
+;;;   "M" + symbol-name : a symbol
+;;;   "G" + pretty-name + unique-name : a gensym
+;;;   "R" + rtd-name + rtd-symbol + field-count + field-names
+;;;   "{" + field-count + rtd + fields
+;;;   ">" + 4-bytes(i) : mark the next object with index i
+;;;   "<" + 4-bytes(i) : dereference the object marked with index i
+;;;
+
+
+(let ()
+  (define write-fixnum 
+    (lambda (x p)
+      (unless (fixnum? x) (error 'write-fixnum "not a fixnum ~s" x))
+      (write-char (integer->char (fxsll (fxlogand x #x3F) 2)) p)
+      (write-char (integer->char (fxlogand (fxsra x 6) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 14) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 22) #xFF)) p)))
+  (define write-int 
+    (lambda (x p)
+      (unless (fixnum? x) (error 'write-int "not a fixnum ~s" x))
+      (write-char (integer->char (fxlogand x #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 8) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 16) #xFF)) p)
+      (write-char (integer->char (fxlogand (fxsra x 24) #xFF)) p)))
+
+  (define fasl-write-immediate
+    (lambda (x p)
+      (cond
+        [(null? x) (write-char #\N p)]
+        [(fixnum? x) 
+         (write-char #\I p)
+         (write-fixnum x p)]
+        [(char? x)
+         (write-char #\C p)
+         (write-char x p)]
+        [(boolean? x)
+         (write-char (if x #\T #\F) p)]
+        [(eof-object? x) (write-char #\E p)]
+        [(eq? x (void)) (write-char #\U p)]
+        [else (error 'fasl-write "~s is not a fasl-writable immediate" x)])))
+
+  (define do-write
+    (lambda (x p h m)
+      (cond
+        [(pair? x)   
+         (write-char #\P p)
+         (fasl-write (cdr x) p h
+           (fasl-write (car x) p h m))]
+        [(vector? x)
+         (write-char #\V p)
+         (write-int (vector-length x) p)
+         (let f ([x x] [i 0] [n (vector-length x)] [m m])
+           (cond
+             [(fx= i n) m]
+             [else
+              (f x (fxadd1 i) n
+                 (fasl-write (vector-ref x i) p h m))]))]
+        [(string? x) 
+         (write-char #\S p)
+         (write-int (string-length x) p)
+         (let f ([x x] [i 0] [n (string-length x)])
+           (cond
+             [(fx= i n) m]
+             [else
+              (write-char (string-ref x i) p)
+              (f x (fxadd1 i) n)]))]
+        [(gensym? x)
+         (write-char #\G p)
+         (fasl-write (gensym->unique-string x) p h
+           (fasl-write (symbol->string x) p h m))]
+        [(symbol? x) 
+         (write-char #\M p)
+         (fasl-write (symbol->string x) p h m)]
+        [(code? x)
+         (write-char #\x p)
+         (write-int (code-size x) p)
+         (write-fixnum (code-freevars x) p)
+         (let f ([i 0] [n (code-size x)])
+           (unless (fx= i n)
+             (write-char (integer->char (code-ref x i)) p)
+             (f (fxadd1 i) n)))
+         (fasl-write (code-reloc-vector x) p h m)]
+        [(record? x)
+         (let ([rtd (record-type-descriptor x)])
+           (cond
+             [(eq? rtd #%$base-rtd)
+              ;;; rtd record
+              (write-char #\R p)
+              (let ([names (record-type-field-names x)]
+                    [m 
+                     (fasl-write (record-type-symbol x) p h
+                       (fasl-write (record-type-name x) p h m))])
+                (write-int (length names) p)
+                (let f ([names names] [m m])
+                  (cond
+                    [(null? names) m]
+                    [else
+                     (f (cdr names)
+                        (fasl-write (car names) p h m))])))]
+             [else
+              ;;; non-rtd record
+              (write-char #\{ p)
+              (write-int (length (record-type-field-names rtd)) p)
+              (let f ([names (record-type-field-names rtd)] 
+                      [m (fasl-write rtd p h m)])
+                (cond
+                  [(null? names) m]
+                  [else
+                   (f (cdr names) 
+                      (fasl-write 
+                         ((record-field-accessor rtd (car names)) x)
+                         p h m))]))]))]
+        [else (error 'fasl-write "~s is not fasl-writable" x)])))
+  (define fasl-write 
+    (lambda (x p h m)
+      (cond
+        [(immediate? x) (fasl-write-immediate x p) m]
+        [(get-hash-table h x #f) =>
+         (lambda (mark)
+           (unless (fixnum? mark)
+             (error 'fasl-write "BUG: invalid mark ~s" mark))
+           (cond
+             [(fx= mark 0) ; singly referenced
+              (do-write x p h m)]
+             [(fx> mark 0) ; marked but not written
+              (put-hash-table! h x (fx- 0 m))
+              (write-char #\> p)
+              (write-int m p)
+              (do-write x p h (fxadd1 m))]
+             [else
+              (write-char #\< p)
+              (write-int (fx- 0 mark) p)
+              m]))]
+        [else (error 'fasl-write "BUG: not in hash table ~s" x)]))) 
+  (define make-graph
+    (lambda (x h)
+      (unless (immediate? x)
+        (cond
+          [(get-hash-table h x #f) =>
+           (lambda (i) 
+             (put-hash-table! h x (fxadd1 i)))]
+          [else
+           (put-hash-table! h x 0)
+           (cond
+             [(pair? x) 
+              (make-graph (car x) h)
+              (make-graph (cdr x) h)]
+             [(vector? x)
+              (let f ([x x] [i 0] [n (vector-length x)])
+                (unless (fx= i n) 
+                  (make-graph (vector-ref x i) h)
+                  (f x (fxadd1 i) n)))]
+             [(symbol? x) 
+              (make-graph (symbol->string x) h)
+              (when (gensym? x) (make-graph (gensym->unique-string x) h))]
+             [(string? x) (void)]
+             [(code? x) 
+              (make-graph (code-reloc-vector x) h)]
+             [(record? x)
+              (when (eq? x #%$base-rtd) 
+                (error 'fasl-write "$base-rtd is not writable"))
+              (let ([rtd (record-type-descriptor x)])
+                (cond
+                  [(eq? rtd #%$base-rtd)
+                   ;;; this is an rtd
+                   (make-graph (record-type-name x) h)
+                   (make-graph (record-type-symbol x) h)
+                   (for-each (lambda (x) (make-graph x h))
+                     (record-type-field-names x))]
+                  [else
+                   ;;; this is a record
+                   (make-graph rtd h)
+                   (for-each 
+                     (lambda (name) 
+                       (make-graph ((record-field-accessor rtd name) x) h))
+                     (record-type-field-names rtd))]))]
+             [else (error 'fasl-write "~s is not fasl-writable" x)])]))))
+  (define do-fasl-write 
+    (lambda (x port)
+      (let ([h (make-hash-table)])
+         (make-graph x h)
+         (write-char #\# port)
+         (write-char #\@ port)
+         (write-char #\I port)
+         (write-char #\K port)
+         (write-char #\0 port)
+         (write-char #\1 port)
+         (fasl-write x port h 1))))
+  (primitive-set! 'fasl-write
+     (case-lambda 
+       [(x) (do-fasl-write x (current-output-port))]
+       [(x port)
+        (unless (output-port? port)
+          (error 'fasl-write "~s is not an output port" port))
+        (do-fasl-write x port)])))
+
diff --git a/src/libhandlers-6.9.ss b/src/libhandlers-6.9.ss
new file mode 100644
index 0000000..1af9a2c
--- /dev/null
+++ b/src/libhandlers-6.9.ss
@@ -0,0 +1,45 @@
+
+(primitive-set! 'error
+  (lambda args
+    (foreign-call "ik_error" args)))
+
+(primitive-set! '$apply-nonprocedure-error-handler
+  (lambda (x)
+    (error 'apply "~s is not a procedure" x)))
+
+(primitive-set! '$incorrect-args-error-handler
+  (lambda (p n)
+    (error 'apply "incorrect number of argument (~s) to ~s" n p)))
+
+(primitive-set! '$multiple-values-error
+  (lambda args
+    (error 'apply 
+           "incorrect number of values ~s returned to single value context" 
+           args)))
+
+(primitive-set! '$debug
+  (lambda (x)
+    (foreign-call "ik_error" (cons "DEBUG" x))))
+
+(primitive-set! '$underflow-misaligned-error
+  (lambda ()
+    (foreign-call "ik_error" "misaligned")))
+
+(primitive-set! 'top-level-value-error
+  (lambda (x)
+    (cond
+      [(symbol? x)
+       (if (top-level-bound? x)
+           (error 'top-level-value "BUG in ~s" x)
+           (error 'top-level-value "~s is unbound" x))]
+      [else
+       (error 'top-level-value "~s is not a symbol" x)])))
+
+(primitive-set! 'car-error
+  (lambda (x)
+    (error 'car "~s is not a pair" x)))
+
+(primitive-set! 'cdr-error
+  (lambda (x)
+    (error 'cdr "~s is not a pair" x)))
+
diff --git a/src/libhandlers.fasl b/src/libhandlers.fasl
index 972862e..768f16c 100644
Binary files a/src/libhandlers.fasl and b/src/libhandlers.fasl differ
diff --git a/src/libhash-6.2.ss b/src/libhash-6.2.ss
index 09861b8..282203f 100644
--- a/src/libhash-6.2.ss
+++ b/src/libhash-6.2.ss
@@ -91,6 +91,8 @@
                ($vector-set! vec idx next)]
               [else 
                (replace! fst b next)])))
+        ;;; reset the tcbucket-tconc FIRST
+        ($set-tcbucket-tconc! b (get-tc h))
         ;;; then add it to the new place
         (let ([k ($tcbucket-key b)])
           (let ([ih (inthash (pointer-value k))])
@@ -98,7 +100,6 @@
               (let ([n ($vector-ref vec idx)])
                 ($set-tcbucket-next! b n)
                 ($vector-set! vec idx b)
-                ($set-tcbucket-tconc! b (get-tc h))
                 (void))))))))
 
   (define get-hash
@@ -129,9 +130,15 @@
                    ($set-tcbucket-val! b v)
                    (void))]
                 [else 
-                 ($vector-set! vec idx
-                   ($make-tcbucket (get-tc h) x v 
-                     ($vector-ref vec idx)))
+                 (let ([bucket
+                        ($make-tcbucket (get-tc h) x v ($vector-ref vec idx))])
+                   (if ($fx= (pointer-value x) pv)
+                       ($vector-set! vec idx bucket)
+                       (let* ([ih (inthash (pointer-value x))]
+                              [idx 
+                               ($fxlogand ih ($fx- ($vector-length vec) 1))])
+                         ($set-tcbucket-next! bucket ($vector-ref vec idx))
+                         ($vector-set! vec idx bucket))))
                  (let ([ct (get-count h)])
                    (set-count! h ($fxadd1 ct))
                    (when ($fx> ct ($vector-length vec))
diff --git a/src/libintelasm-6.0.ss b/src/libintelasm-6.0.ss
index e86a3c9..38900da 100644
--- a/src/libintelasm-6.0.ss
+++ b/src/libintelasm-6.0.ss
@@ -375,13 +375,13 @@
          ac)])))
 
 
-#;(define CODErd
-  (lambda (c r1 disp ac)
-    (with-args disp
-      (lambda (i/r r2)
-        (if (reg? i/r)
-            (CODE c (RegReg r1 i/r r2 ac))
-            (CODErri c r1 r2 i/r ac))))))
+;;(define CODErd
+;;  (lambda (c r1 disp ac)
+;;    (with-args disp
+;;      (lambda (i/r r2)
+;;        (if (reg? i/r)
+;;            (CODE c (RegReg r1 i/r r2 ac))
+;;            (CODErri c r1 r2 i/r ac))))))
 
 
 (define IMM32*2
diff --git a/src/libintelasm-6.4.ss b/src/libintelasm-6.4.ss
new file mode 100644
index 0000000..e1094b5
--- /dev/null
+++ b/src/libintelasm-6.4.ss
@@ -0,0 +1,920 @@
+
+;;; 
+;;; assuming the existence of a code manager, this file defines an assember
+;;; that takes lists of assembly code and produces a list of code objects
+;;;
+
+   ;;;      add     
+   ;;;      and
+   ;;;      cmp
+   ;;;      call
+   ;;;      cltd
+   ;;;      idiv
+   ;;;      imull
+   ;;;      ja
+   ;;;      jae
+   ;;;      jb
+   ;;;      jbe
+   ;;;      je
+   ;;;      jg
+   ;;;      jge
+   ;;;      jl
+   ;;;      jle
+   ;;;      jne
+   ;;;      jmp
+   ;;;      movb
+   ;;;      movl
+   ;;;      negl
+   ;;;      notl
+   ;;;      orl
+   ;;;      popl
+   ;;;      pushl
+   ;;;      ret
+   ;;;      sall
+   ;;;      sarl
+   ;;;      shrl
+   ;;;      sete
+   ;;;      setg
+
+
+(let ()
+
+(define fold
+  (lambda (f init ls)
+    (cond
+      [(null? ls) init]
+      [else
+       (f (car ls) (fold f init (cdr ls)))])))
+
+(define convert-instructions
+  (lambda (ls)
+    (fold convert-instruction '() ls)))
+
+(define register-mapping
+  '([%eax 32 0] 
+    [%ecx 32 1]
+    [%edx 32 2]
+    [%ebx 32 3]
+    [%esp 32 4]
+    [%ebp 32 5]
+    [%esi 32 6]
+    [%edi 32 7]
+    [%al   8 0]
+    [%cl   8 1]
+    [%dl   8 2]
+    [%bl   8 3]
+    [%ah   8 4]
+    [%ch   8 5]
+    [%dh   8 6]
+    [%bh   8 7]
+    [/0   0  0]
+    [/1   0  1]
+    [/2   0  2]
+    [/3   0  3]
+    [/4   0  4]
+    [/5   0  5]
+    [/6   0  6]
+    [/7   0  7]
+    ))
+  
+(define register-index
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) => caddr]
+      [else (error 'register-index "not a register ~s" x)])))
+
+(define reg32?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 32))]
+      [else #f])))
+
+(define reg8?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 8))]
+      [else #f])))
+
+(define reg?
+  (lambda (x)
+    (assq x register-mapping)))
+
+(define check-len
+  (lambda (x)
+    (define instr-len
+      '([ret]
+        [movl s d]
+        [movb s d]
+        [addl s d]
+        [subl s d]
+        [sall s d]
+        [sarl s d]
+        [shrl s d]
+        [andl s d]
+        [xorl s d]
+        [orl s d]
+        [cmpl s d]
+        [imull s d]
+        [notl d]
+        [negl d]
+        [idivl d]
+        [pushl d]
+        [popl d]
+        [jmp d]
+        [call d]
+        [ja d]
+        [jae d]
+        [jb d]
+        [jbe d]
+        [je d]
+        [jg d]
+        [jge d]
+        [jl d]
+        [jle d]
+        [jna d]
+        [jnae d]
+        [jnb d]
+        [jnbe d]
+        [jne d]
+        [jng d]
+        [jnge d]
+        [jnl d]
+        [jnle d]
+        [seta d]
+        [setae d]
+        [setb d]
+        [setbe d]
+        [sete d]
+        [setg d]
+        [setge d]
+        [setl d]
+        [setle d]
+        [setna d]
+        [setnae d]
+        [setnb d]
+        [setnbe d]
+        [setne d]
+        [setng d]
+        [setnge d]
+        [setnl d]
+        [setnle d]
+        [cltd]
+        [nop]
+        [byte x]
+        [byte-vector x]
+        [int x]
+        [label x]
+        [label-address x]
+        [current-frame-offset]
+        ))
+    (cond
+      [(assq (car x) instr-len) =>
+       (lambda (p) 
+         (unless (fx= (length x) (length p))
+           (error 'assembler "invalid instruction format ~s" x)))]
+      [else (error 'assembler "unknown instruction ~s" x)])))
+
+(define with-args
+  (lambda (ls f)
+    (apply f (cdr ls))))
+
+(define byte
+  (lambda (x)
+    (cons 'byte (fxlogand x 255))))
+
+
+(define word
+  (lambda (x)
+    (cons 'word x)))
+
+(define reloc-word
+  (lambda (x)
+    (cons 'reloc-word x)))
+
+(define reloc-word+
+  (lambda (x d)
+    (list* 'reloc-word+ x d)))
+
+(define list*-aux
+  (lambda (ls ls*)
+    (cond
+      [(null? ls*) ls]
+      [else (cons ls (list*-aux (car ls*) (cdr ls*)))])))
+
+(define list*
+  (lambda (ls . ls*)
+    (list*-aux ls ls*)))
+
+(define byte?
+  (lambda (x)
+    (and (fixnum? x)
+         (fx<= x 127)
+         (fx<= -128 x))))
+
+(define mem?
+  (lambda (x)
+    (and (list? x)
+         (fx= (length x) 3)
+         (eq? (car x) 'disp)
+         (or (imm? (cadr x))
+             (reg? (cadr x)))
+         (or (imm? (caddr x))
+             (reg? (caddr x))))))
+
+(define small-disp?
+  (lambda (x)
+    (and (mem? x)
+         (byte? (cadr x)))))
+
+
+(define CODE
+  (lambda (n ac)
+    (cons (byte n) ac)))
+
+(define CODE+r
+  (lambda (n r ac)
+    (cons (byte (fxlogor n (register-index r))) ac)))
+
+(define ModRM
+  (lambda (mod reg r/m ac)
+    (cons (byte (fxlogor 
+                  (register-index r/m)
+                  (fxlogor 
+                    (fxsll (register-index reg) 3)
+                    (fxsll mod 6))))
+          (if (and (not (fx= mod 3)) (eq? r/m '%esp))
+              (cons (byte #x24) ac)
+              ac))))
+
+(define IMM32
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n)
+           (byte (fxsra n  8))
+           (byte (fxsra n 16))
+           (byte (fxsra n 24))
+           ac))]
+      [(obj? n)
+       (let ([v (cadr n)])
+         (if (immediate? v)
+             (cons (word v) ac)
+             (cons (reloc-word v) ac)))]
+      [(obj+? n)
+       (let ([v (cadr n)] [d (caddr n)])
+         (cons (reloc-word+ v d) ac))]
+      [(label-address? n)
+       (cons (cons 'label-addr (label-name n)) ac)]
+      [(foreign? n)
+       (cons (cons 'foreign-label (label-name n)) ac)]
+      [else (error 'IMM32 "invalid ~s" n)])))
+
+
+(define IMM8
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n) ac))]
+      [else (error 'IMM8 "invalid ~s" n)])))
+
+
+(define imm?
+  (lambda (x)
+    (or (int? x)
+        (obj? x)
+        (obj+? x) 
+        (label-address? x)
+        (foreign? x))))
+
+(define foreign?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'foreign-label))))
+
+
+(define imm8?
+  (lambda (x)
+    (and (int? x) (byte? (cadr x)))))
+
+(define label?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (symbol? (car d)))
+           (error 'assemble "invalid label ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-address?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label-address))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (or (symbol? (car d))
+                          (string? (car d))))
+           (error 'assemble "invalid label-address ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-name
+  (lambda (x) (cadr x)))
+
+(define int?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'int))))
+
+(define obj?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj))))
+
+(define obj+?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj+))))
+
+(define CODErri
+  (lambda (c d s i ac)
+    (cond
+      [(imm8? i)
+       (CODE c (ModRM 1 d s (IMM8 i ac)))]
+      [(reg? i) 
+       (CODE c (ModRM i d s ac))]
+      [else
+       (CODE c (ModRM 2 d s (IMM32 i ac)))])))
+
+(define CODErr
+  (lambda (c d s ac)
+    (CODE c (ModRM 3 d s ac))))
+
+(define CODEri
+  (lambda (c d i ac)
+    (CODE+r c d (IMM32 i ac))))
+
+
+(define RegReg
+  (lambda (r1 r2 r3 ac)
+    (cond
+      [(eq? r3 '%esp) (error 'assembler "BUG: invalid src %esp")]
+      [(eq? r1 '%ebp) (error 'assembler "BUG: invalid src %ebp")]
+      [else 
+;;;       (parameterize ([print-radix 16])
+;;;          (printf "REGREG ~s ~s ~s\n" r1 r2 r3)
+;;;          (printf "REGREG ~s ~s\n" 
+;;;            (byte (fxlogor 4 (fxsll (register-index r1) 3)))
+;;;            (byte (fxlogor (register-index r2) 
+;;;                           (fxsll (register-index r3) 3)))))
+       (list*
+         (byte (fxlogor 4 (fxsll (register-index r1) 3)))
+         (byte (fxlogor (register-index r2) 
+                        (fxsll (register-index r3) 3)))
+         ac)])))
+
+
+;;(define CODErd
+;;  (lambda (c r1 disp ac)
+;;    (with-args disp
+;;      (lambda (i/r r2)
+;;        (if (reg? i/r)
+;;            (CODE c (RegReg r1 i/r r2 ac))
+;;            (CODErri c r1 r2 i/r ac))))))
+
+
+(define IMM32*2
+  (lambda (i1 i2 ac)
+    (cond
+      [(and (int? i1) (obj? i2))
+       (let ([d (cadr i1)] [v (cadr i2)])
+         (cons (reloc-word+ v d) ac))]
+      [else (error 'assemble "IMM32*2 ~s ~s" i1 i2)])))
+
+
+(define CODErd
+  (lambda (c r1 disp ac)
+    (with-args disp
+      (lambda (a1 a2)
+        (cond
+          [(and (reg? a1) (reg? a2))
+           (CODE c (RegReg r1 a1 a2 ac))]
+          [(and (imm? a1) (reg? a2))
+           (CODErri c r1 a2 a1 ac)]
+          [(and (imm? a1) (imm? a2))
+           (CODE c 
+             (ModRM 0 r1 '/5 
+               (IMM32*2 a1 a2 ac)))]
+          [else (error 'CODErd "unhandled ~s" disp)])))))
+
+(define CODEdi
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (i r)
+        (CODErri c '/0 r i (IMM32 n ac))))))
+
+(define CODEdi8
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (i r)
+        (CODErri c '/0 r i (IMM8 n ac))))))
+
+(define *cogen* (gensym "*cogen*"))
+
+(define-syntax add-instruction
+  (syntax-rules ()
+    [(_ (name instr ac args ...) b b* ...)
+     (putprop 'name *cogen*
+       (cons (length '(args ...))
+             (lambda (instr ac args ...) b b* ...)))]))
+
+(define-syntax add-instructions
+  (syntax-rules ()
+    [(_ instr ac [(name* arg** ...) b* b** ...] ...)
+     (begin
+       (add-instruction (name* instr ac arg** ...) b* b** ...) ...)]))
+
+(define (convert-instruction a ac)
+  (cond
+    [(getprop (car a) *cogen*) =>
+     (lambda (p)
+       (let ([n (car p)] [proc (cdr p)] [args (cdr a)])
+         (cond
+           [(fx= n (length args))
+            (apply proc a ac args)]
+           [else 
+            (error 'convert-instruction "incorrect args in ~s" a)])))]
+    [else (old-convert-instruction a ac)]
+    ;[else (error 'convert-instruction "unknown instruction in ~s" a)]
+    ))
+
+(module ()
+(define who 'assembler)
+(add-instructions instr ac
+  [(ret) (CODE #xC3 ac)]
+  [(cltd) (CODE #x99 ac)]
+  [(movl src dst)
+   (cond
+     [(and (imm? src) (reg? dst))  (CODEri #xB8 dst src ac)]
+     [(and (imm? src) (mem? dst))  (CODEdi #xC7 dst src ac)]
+     [(and (reg? src) (reg? dst))  (CODErr #x89 src dst ac)]
+     [(and (reg? src) (mem? dst))  (CODErd #x89 src dst ac)]
+     [(and (mem? src) (reg? dst))  (CODErd #x8B dst src ac)] 
+     [else (error who "invalid ~s" instr)])]
+   [(movb src dst)
+    (cond
+      ;[(and (imm8? src) (reg8? dst))  (CODEri #xB0 dst src ac)]
+      [(and (imm8? src) (mem? dst)) (CODEdi8 #xC6 dst src ac)]
+      ;[(and (reg8? src) (reg8? dst))  (CODErr #x88 src dst ac)]
+      [(and (reg8? src) (mem? dst))   (CODErd #x88 src dst ac)]
+      [(and (mem? src) (reg8? dst))   (CODErd #x8A dst src ac)] 
+      [else (error who "invalid ~s" instr)])]
+   [(addl src dst)
+    (cond   
+      ;;; add imm -> reg
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/0 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x05 (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/0 dst (IMM32 src ac)))]
+      ;;; add reg -> reg
+      [(and (reg? src) (reg? dst))
+       (CODE #x01 (ModRM 3 src dst ac))]
+      ;;; add mem -> reg
+      [(and (mem? src) (reg? dst))
+       (CODErd #x03 dst src ac)]
+      ;;; add imm -> mem (not needed)
+      ;;; add reg -> mem (not needed)
+      [else (error who "invalid ~s" instr)])]
+   [(subl src dst)
+    (cond   
+      ;;; imm -> reg
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/5 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x2D (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/5 dst (IMM32 src ac)))]
+      ;;; reg -> reg
+      [(and (reg? src) (reg? dst))
+       (CODE #x29 (ModRM 3 src dst ac))]
+      ;;; mem -> reg
+      [(and (mem? src) (reg? dst))
+       (CODErd #x2B dst src ac)]
+      ;;; imm -> mem (not needed)
+      ;;; reg -> mem (not needed)
+      [else (error who "invalid ~s" instr)])]
+   [(sall src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/4 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/4 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/4 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(shrl src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/5 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/5 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/5 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(sarl src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/7 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/7 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/7 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(andl src dst) 
+        (cond
+          ;;; and imm -> reg
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/4 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x25 (IMM32 src ac))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x81 (ModRM 3 '/4 dst (IMM32 src ac)))]
+          ;;; and reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x21 (ModRM 3 src dst ac))]
+          ;;; and mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x23 dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(orl src dst) 
+        (cond
+          ;;; or imm -> reg
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/1 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x0D (IMM32 src ac))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x81 (ModRM 3 '/1 dst (IMM32 src ac)))]
+          ;;; or reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x09 (ModRM 3 src dst ac))]
+          ;;; or mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x0B dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(xorl src dst) 
+        (cond
+          ;;; or imm -> reg
+          ;[(and (imm8? src) (reg? dst)) 
+          ; (CODE #x83 (ModRM 3 '/1 dst (IMM8 src ac)))]
+          ;[(and (imm? src) (eq? dst '%eax)) 
+          ; (CODE #x0D (IMM32 src ac))]
+          ;[(and (imm? src) (reg? dst))
+          ; (CODE #x81 (ModRM 3 '/1 dst (IMM32 src ac)))]
+          ;;; or reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x31 (ModRM 3 src dst ac))]
+          ;;; or mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x33 dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(cmpl src dst)
+        (cond
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/7 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x3D (IMM32 src ac))]
+          [(and (reg? src) (reg? dst))
+           (CODE #x39 (ModRM 3 src dst ac))]
+          [(and (mem? src) (reg? dst))
+           (CODErd #x3B dst src ac)]
+          [(and (imm8? src) (mem? dst))
+           (CODErd #x83 '/7 dst (IMM8 src ac))]
+          [(and (imm? src) (mem? dst))
+           (CODErd #x81 '/7 dst (IMM32 src ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(imull src dst)
+        (cond
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x6B (ModRM 3 dst dst (IMM8 src ac)))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x69 (ModRM 3 dst dst (IMM32 src ac)))]
+          [(and (reg? src) (reg? dst))
+           (CODE #x0F (CODE #xAF (ModRM 3 dst src ac)))]
+          [(and (mem? src) (reg? dst))
+           (CODE #x0F (CODErd #xAF dst src ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(idivl dst)
+        (cond
+          [(reg? dst)
+           (CODErr #xF7 '/7 dst ac)]
+          [(mem? dst)
+           (CODErd #xF7 '/7 dst ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(pushl dst)
+        (cond
+          [(imm8? dst) 
+           (CODE #x6A (IMM8 dst ac))]
+          [(imm? dst)
+           (CODE #x68 (IMM32 dst ac))]
+          [(reg? dst)
+           (CODE+r #x50 dst ac)]
+          [(mem? dst)
+           (CODErd #xFF '/6 dst ac)]
+          [else (error who "invalid ~s" instr)])] 
+   [(popl dst)
+        (cond
+          [(reg? dst)
+           (CODE+r #x58 dst ac)]
+          [(mem? dst)
+           (CODErd #x8F '/0 dst ac)]
+          [else (error who "invalid ~s" instr)])] 
+   [(notl dst)
+        (cond
+          [(reg? dst)
+           (CODE #xF7 (ModRM 3 '/2 dst ac))]
+          [(mem? dst)
+           (CODErd #xF7 '/7 dst ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(negl dst)
+        (cond
+          [(reg? dst)
+           (CODE #xF7 (ModRM 3 '/3 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+
+))
+
+(define old-convert-instruction
+  (lambda (a ac)
+    (define who 'assemble)
+    (check-len a)
+    (case (car a)
+
+      [(jmp)
+       (with-args a
+         (lambda (dst)
+           (cond
+             [(label? dst)
+              (CODE #xE9 (cons (cons 'relative (label-name dst)) ac))]
+             [(imm? dst) 
+              (CODE #xE9 (IMM32 dst ac))]
+             [(mem? dst)
+              (CODErd #xFF '/4 dst ac)]
+             [else (error who "invalid jmp in ~s" a)])))]
+      [(call)
+       (with-args a
+         (lambda (dst)
+           (cond
+             [(imm? dst) 
+              (CODE #xE8 (IMM32 dst ac))]
+             [(label? dst)
+              (CODE #xE8 (cons (cons 'relative (label-name dst)) ac))]
+             [(mem? dst)
+              (CODErd #xFF '/2 dst ac)]
+             [(reg? dst)
+              (CODE #xFF (ModRM 3 '/2 dst ac))]
+             [else (error who "invalid jmp in ~s" a)])))]
+      [(seta  setae  setb  setbe  sete  setg  setge  setl  setle
+        setna setnae setnb setnbe setne setng setnge setnl setnle)
+       (let* ([table
+               '([seta  #x97] [setna  #x96] 
+                 [setae #x93] [setnae #x92]
+                 [setb  #x92] [setnb  #x93]
+                 [setbe #x96] [setnbe #x97]
+                 [setg  #x9F] [setng  #x9E]
+                 [setge #x9D] [setnge #x9C]
+                 [setl  #x9C] [setnl  #x9D]
+                 [setle #x9E] [setnle #x9F]
+                 [sete  #x94] [setne  #x95])]
+              [lookup
+               (lambda (x)
+                 (cond
+                   [(assq x table) => cadr]
+                   [else (error who "invalid cset ~s" x)]))])
+         (with-args a
+           (lambda (dst)
+             (cond
+               [(reg8? dst)
+                (CODE #x0F 
+                  (CODE (lookup (car a)) 
+                    (ModRM 3 '/0 dst ac)))]
+               [else (error who "invalid ~s" a)]))))]
+      [(ja  jae  jb  jbe  je  jg  jge  jl  jle
+        jna jnae jnb jnbe jne jng jnge jnl jnle)
+       (let* ([table 
+               '([je #x84]  [jne #x85]
+                 [ja #x87]  [jna #x86]
+                 [jae #x83] [jnae #x82] 
+                 [jb #x82]  [jnb #x83]
+                 [jbe #x86] [jnbe #x87] 
+                 [jg #x8F]  [jng #x8E] 
+                 [jge #x8D] [jnge #x8C]
+                 [jl #x8C]  [jnl #x8D]
+                 [jle #x8E] [jnle #x8F])]
+              [lookup
+               (lambda (x)
+                 (cond
+                   [(assq x table) => cadr]
+                   [else (error who "invalid cmp ~s" x)]))])
+         (with-args a
+           (lambda (dst)
+             (cond
+               [(imm? dst)
+                (CODE #x0F (CODE (lookup (car a)) (IMM32 dst ac)))]
+               [(label? dst)
+                (CODE #x0F 
+                  (CODE (lookup (car a)) 
+                    (cons (cons 'relative (label-name dst)) ac)))]
+               [else (error who "invalid ~s" a)]))))]
+      [(byte) 
+       (with-args a
+         (lambda (x)
+           (unless (byte? x) (error who "invalid instruction ~s" a))
+           (cons (byte x) ac)))]
+      [(byte-vector)
+       (with-args a
+         (lambda (x) (append (map byte (vector->list x)) ac)))]
+      [(int) (IMM32 a ac)] 
+      [(label)
+       (with-args a 
+         (lambda (L)
+           (unless (symbol? L) (error who "invalid instruction ~s" a))
+           (cons (cons 'label L) ac)))]
+      [(label-address)
+       (with-args a 
+         (lambda (L)
+           (unless (symbol? L) (error who "invalid instruction ~s" a))
+           (cons (cons 'label-addr L) ac)))]
+      [(current-frame-offset)
+       (cons '(current-frame-offset) ac)]
+      [(nop) ac]
+      [else
+       (error who "unknown instruction ~s" a)])))
+
+(define diff
+  (lambda (ls x)
+    (cond
+      [(eq? ls x) '()]
+      [else (cons (car ls) (diff (cdr ls) x))])))
+
+(define hex-table
+  '#(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7
+     #\8 #\9 #\A #\B #\C #\D #\E #\F))
+
+(define write/x
+  (lambda (x)
+    (case (car x)
+      [(byte)
+       (display "0x")
+       (display (vector-ref hex-table (fxsra (cdr x) 4)))
+       (display (vector-ref hex-table (fxlogand (cdr x) 15)))
+       (display " ")]
+      [else (write x)])))
+
+
+(define compute-code-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (case (car x)
+              [(byte) (fx+ ac 1)]
+              [(word reloc-word reloc-word+ label-addr foreign-label 
+                relative current-frame-offset)
+               (fx+ ac 4)]
+              [(label) ac]
+              [else (error 'compute-code-size "unknown instr ~s" x)]))
+          0 
+          ls)))
+
+
+(define compute-reloc-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (case (car x)
+              [(reloc-word )       (fx+ ac 4)]
+              [(reloc-word+)      (fx+ ac 8)]
+              [(relative label-addr foreign-label)         (fx+ ac 8)]
+              [(word byte label current-frame-offset)   ac]
+              [else (error 'compute-reloc-size "unknown instr ~s" x)]))
+          0 
+          ls)))
+
+(define set-label-loc!
+  (lambda (x loc)
+    (when (getprop x '*label-loc*)
+      (error 'compile "label ~s is already defined" x))
+    (putprop x '*label-loc* loc)))
+
+(define label-loc
+  (lambda (x)
+    (or (getprop x '*label-loc*)
+        (error 'compile "undefined label ~s" x))))
+
+
+(define unset-label-loc!
+  (lambda (x)
+    (remprop x '*label-loc*)))
+
+
+(define whack-instructions
+  (lambda (x ls)
+    (define f
+      (lambda (ls idx reloc)
+        (cond
+          [(null? ls) reloc]
+          [else
+           (let ([a (car ls)])
+             (case (car a)
+               [(byte) 
+                (set-code-byte! x idx (cdr a))
+                (f (cdr ls) (fx+ idx 1) reloc)]
+               [(reloc-word reloc-word+)
+                (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+               [(relative label-addr foreign-label) 
+                (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+               [(word)
+                (let ([v (cdr a)])
+                   (set-code-word! x idx v)
+                   (f (cdr ls) (fx+ idx 4) reloc))]
+               [(current-frame-offset)
+                (set-code-word! x idx idx)
+                (f (cdr ls) (fx+ idx 4) reloc)]
+               [(label)
+                (set-label-loc! (cdr a) (cons x idx))
+                (f (cdr ls) idx reloc)]
+               [else
+                (error 'whack-instructions "unknown instr ~s" a)]))])))
+    (f ls 0 '())))
+
+(define wordsize 4)
+
+(define whack-reloc
+  (lambda (code)
+    (define reloc-idx 0)
+    (lambda (r)
+      (let ([idx (car r)] [type (cadr r)] [v (cddr r)])
+        (case type
+          [(reloc-word)
+           (set-code-object! code v idx reloc-idx)
+           (set! reloc-idx (fxadd1 reloc-idx))]
+          [(foreign-label)
+           (set-code-foreign-object! code v idx reloc-idx)
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(reloc-word+)
+           (let ([obj (car v)] [disp (cdr v)])
+             (set-code-object+offset! code obj idx disp reloc-idx)
+             (set! reloc-idx (fx+ reloc-idx 2)))]
+          [(label-addr)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [off (cdr loc)])
+               (set-code-object+offset! 
+                 code obj idx (fx+ off 11) reloc-idx)))
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(relative)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [off (cdr loc)])
+               (set-code-object+offset/rel! 
+                 code obj idx (fx+ off 11) reloc-idx)))
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [else (error 'whack-reloc "invalid reloc type ~s" type)]))
+      )))
+
+
+;;; (define list->code
+;;;   (lambda (ls)
+;;;     (let ([ls (convert-instructions ls)])
+;;;       (let ([n (compute-code-size ls)]
+;;;             [m (compute-reloc-size ls)])
+;;;         (let ([x (make-code n m 1)])
+;;;           (let ([reloc* (whack-instructions x ls)])
+;;;             (for-each (whack-reloc x) reloc*))
+;;;           (make-code-executable! x)
+;;;           x)))))
+
+(define list*->code*
+  (lambda (ls*)
+    (let ([closure-size* (map car ls*)]
+          [ls* (map cdr ls*)])
+      (let ([ls* (map convert-instructions ls*)])
+        (let ([n* (map compute-code-size ls*)]
+              [m* (map compute-reloc-size ls*)])
+          (let ([code* (map (lambda (n m c) (make-code n m c))
+                            n* 
+                            m*
+                            closure-size*)])
+            (let ([reloc** (map whack-instructions code* ls*)])
+              (for-each
+                (lambda (code reloc*)
+                  (for-each (whack-reloc code) reloc*))
+                code* reloc**)
+              (for-each make-code-executable! code*)
+              code*)))))))
+
+(define list->code
+  (lambda (ls)
+    (car (list*->code* (list ls)))))
+
+(primitive-set! 'list*->code* list*->code*)
+)
diff --git a/src/libintelasm-6.6.ss b/src/libintelasm-6.6.ss
new file mode 100644
index 0000000..7254753
--- /dev/null
+++ b/src/libintelasm-6.6.ss
@@ -0,0 +1,932 @@
+
+;;; 
+;;; assuming the existence of a code manager, this file defines an assember
+;;; that takes lists of assembly code and produces a list of code objects
+;;;
+
+   ;;;      add     
+   ;;;      and
+   ;;;      cmp
+   ;;;      call
+   ;;;      cltd
+   ;;;      idiv
+   ;;;      imull
+   ;;;      ja
+   ;;;      jae
+   ;;;      jb
+   ;;;      jbe
+   ;;;      je
+   ;;;      jg
+   ;;;      jge
+   ;;;      jl
+   ;;;      jle
+   ;;;      jne
+   ;;;      jmp
+   ;;;      movb
+   ;;;      movl
+   ;;;      negl
+   ;;;      notl
+   ;;;      orl
+   ;;;      popl
+   ;;;      pushl
+   ;;;      ret
+   ;;;      sall
+   ;;;      sarl
+   ;;;      shrl
+   ;;;      sete
+   ;;;      setg
+
+
+(let ()
+
+(define fold
+  (lambda (f init ls)
+    (cond
+      [(null? ls) init]
+      [else
+       (f (car ls) (fold f init (cdr ls)))])))
+
+(define convert-instructions
+  (lambda (ls)
+    (fold convert-instruction '() ls)))
+
+(define register-mapping
+  '([%eax 32 0] 
+    [%ecx 32 1]
+    [%edx 32 2]
+    [%ebx 32 3]
+    [%esp 32 4]
+    [%ebp 32 5]
+    [%esi 32 6]
+    [%edi 32 7]
+    [%al   8 0]
+    [%cl   8 1]
+    [%dl   8 2]
+    [%bl   8 3]
+    [%ah   8 4]
+    [%ch   8 5]
+    [%dh   8 6]
+    [%bh   8 7]
+    [/0   0  0]
+    [/1   0  1]
+    [/2   0  2]
+    [/3   0  3]
+    [/4   0  4]
+    [/5   0  5]
+    [/6   0  6]
+    [/7   0  7]
+    ))
+  
+(define register-index
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) => caddr]
+      [else (error 'register-index "not a register ~s" x)])))
+
+(define reg32?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 32))]
+      [else #f])))
+
+(define reg8?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 8))]
+      [else #f])))
+
+(define reg?
+  (lambda (x)
+    (assq x register-mapping)))
+
+(define check-len
+  (lambda (x)
+    (define instr-len
+      '([ret]
+        [movl s d]
+        [movb s d]
+        [addl s d]
+        [subl s d]
+        [sall s d]
+        [sarl s d]
+        [shrl s d]
+        [andl s d]
+        [xorl s d]
+        [orl s d]
+        [cmpl s d]
+        [imull s d]
+        [notl d]
+        [negl d]
+        [idivl d]
+        [pushl d]
+        [popl d]
+        [jmp d]
+        [call d]
+        [ja d]
+        [jae d]
+        [jb d]
+        [jbe d]
+        [je d]
+        [jg d]
+        [jge d]
+        [jl d]
+        [jle d]
+        [jna d]
+        [jnae d]
+        [jnb d]
+        [jnbe d]
+        [jne d]
+        [jng d]
+        [jnge d]
+        [jnl d]
+        [jnle d]
+        [seta d]
+        [setae d]
+        [setb d]
+        [setbe d]
+        [sete d]
+        [setg d]
+        [setge d]
+        [setl d]
+        [setle d]
+        [setna d]
+        [setnae d]
+        [setnb d]
+        [setnbe d]
+        [setne d]
+        [setng d]
+        [setnge d]
+        [setnl d]
+        [setnle d]
+        [cltd]
+        [nop]
+        [byte x]
+        [byte-vector x]
+        [int x]
+        [label x]
+        [label-address x]
+        [current-frame-offset]
+        ))
+    (cond
+      [(assq (car x) instr-len) =>
+       (lambda (p) 
+         (unless (fx= (length x) (length p))
+           (error 'assembler "invalid instruction format ~s" x)))]
+      [else (error 'assembler "unknown instruction ~s" x)])))
+
+(define with-args
+  (lambda (ls f)
+    (apply f (cdr ls))))
+
+(define byte
+  (lambda (x)
+    (cons 'byte (fxlogand x 255))))
+
+
+(define word
+  (lambda (x)
+    (cons 'word x)))
+
+(define reloc-word
+  (lambda (x)
+    (cons 'reloc-word x)))
+
+(define reloc-word+
+  (lambda (x d)
+    (list* 'reloc-word+ x d)))
+
+(define list*-aux
+  (lambda (ls ls*)
+    (cond
+      [(null? ls*) ls]
+      [else (cons ls (list*-aux (car ls*) (cdr ls*)))])))
+
+(define list*
+  (lambda (ls . ls*)
+    (list*-aux ls ls*)))
+
+(define byte?
+  (lambda (x)
+    (and (fixnum? x)
+         (fx<= x 127)
+         (fx<= -128 x))))
+
+(define mem?
+  (lambda (x)
+    (and (list? x)
+         (fx= (length x) 3)
+         (eq? (car x) 'disp)
+         (or (imm? (cadr x))
+             (reg? (cadr x)))
+         (or (imm? (caddr x))
+             (reg? (caddr x))))))
+
+(define small-disp?
+  (lambda (x)
+    (and (mem? x)
+         (byte? (cadr x)))))
+
+
+(define CODE
+  (lambda (n ac)
+    (cons (byte n) ac)))
+
+(define CODE+r
+  (lambda (n r ac)
+    (cons (byte (fxlogor n (register-index r))) ac)))
+
+(define ModRM
+  (lambda (mod reg r/m ac)
+    (cons (byte (fxlogor 
+                  (register-index r/m)
+                  (fxlogor 
+                    (fxsll (register-index reg) 3)
+                    (fxsll mod 6))))
+          (if (and (not (fx= mod 3)) (eq? r/m '%esp))
+              (cons (byte #x24) ac)
+              ac))))
+
+(define IMM32
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n)
+           (byte (fxsra n  8))
+           (byte (fxsra n 16))
+           (byte (fxsra n 24))
+           ac))]
+      [(obj? n)
+       (let ([v (cadr n)])
+         (if (immediate? v)
+             (cons (word v) ac)
+             (cons (reloc-word v) ac)))]
+      [(obj+? n)
+       (let ([v (cadr n)] [d (caddr n)])
+         (cons (reloc-word+ v d) ac))]
+      [(label-address? n)
+       (cons (cons 'label-addr (label-name n)) ac)]
+      [(foreign? n)
+       (cons (cons 'foreign-label (label-name n)) ac)]
+      [else (error 'IMM32 "invalid ~s" n)])))
+
+
+(define IMM8
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n) ac))]
+      [else (error 'IMM8 "invalid ~s" n)])))
+
+
+(define imm?
+  (lambda (x)
+    (or (int? x)
+        (obj? x)
+        (obj+? x) 
+        (label-address? x)
+        (foreign? x))))
+
+(define foreign?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'foreign-label))))
+
+
+(define imm8?
+  (lambda (x)
+    (and (int? x) (byte? (cadr x)))))
+
+(define label?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (symbol? (car d)))
+           (error 'assemble "invalid label ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-address?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label-address))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (or (symbol? (car d))
+                          (string? (car d))))
+           (error 'assemble "invalid label-address ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-name
+  (lambda (x) (cadr x)))
+
+(define int?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'int))))
+
+(define obj?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj))))
+
+(define obj+?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj+))))
+
+(define CODErri
+  (lambda (c d s i ac)
+    (cond
+      [(imm8? i)
+       (CODE c (ModRM 1 d s (IMM8 i ac)))]
+      [(reg? i) 
+       (CODE c (ModRM i d s ac))]
+      [else
+       (CODE c (ModRM 2 d s (IMM32 i ac)))])))
+
+(define CODErr
+  (lambda (c d s ac)
+    (CODE c (ModRM 3 d s ac))))
+
+(define CODEri
+  (lambda (c d i ac)
+    (CODE+r c d (IMM32 i ac))))
+
+
+(define RegReg
+  (lambda (r1 r2 r3 ac)
+    (cond
+      [(eq? r3 '%esp) (error 'assembler "BUG: invalid src %esp")]
+      [(eq? r1 '%ebp) (error 'assembler "BUG: invalid src %ebp")]
+      [else 
+;;;       (parameterize ([print-radix 16])
+;;;          (printf "REGREG ~s ~s ~s\n" r1 r2 r3)
+;;;          (printf "REGREG ~s ~s\n" 
+;;;            (byte (fxlogor 4 (fxsll (register-index r1) 3)))
+;;;            (byte (fxlogor (register-index r2) 
+;;;                           (fxsll (register-index r3) 3)))))
+       (list*
+         (byte (fxlogor 4 (fxsll (register-index r1) 3)))
+         (byte (fxlogor (register-index r2) 
+                        (fxsll (register-index r3) 3)))
+         ac)])))
+
+
+;;(define CODErd
+;;  (lambda (c r1 disp ac)
+;;    (with-args disp
+;;      (lambda (i/r r2)
+;;        (if (reg? i/r)
+;;            (CODE c (RegReg r1 i/r r2 ac))
+;;            (CODErri c r1 r2 i/r ac))))))
+
+
+(define IMM32*2
+  (lambda (i1 i2 ac)
+    (cond
+      [(and (int? i1) (obj? i2))
+       (let ([d (cadr i1)] [v (cadr i2)])
+         (cons (reloc-word+ v d) ac))]
+      [else (error 'assemble "IMM32*2 ~s ~s" i1 i2)])))
+
+
+(define CODErd
+  (lambda (c r1 disp ac)
+    (with-args disp
+      (lambda (a1 a2)
+        (cond
+          [(and (reg? a1) (reg? a2))
+           (CODE c (RegReg r1 a1 a2 ac))]
+          [(and (imm? a1) (reg? a2))
+           (CODErri c r1 a2 a1 ac)]
+          [(and (imm? a1) (imm? a2))
+           (CODE c 
+             (ModRM 0 r1 '/5 
+               (IMM32*2 a1 a2 ac)))]
+          [else (error 'CODErd "unhandled ~s" disp)])))))
+
+(define CODEdi
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (i r)
+        (CODErri c '/0 r i (IMM32 n ac))))))
+
+(define CODEdi8
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (i r)
+        (CODErri c '/0 r i (IMM8 n ac))))))
+
+(define *cogen* (gensym "*cogen*"))
+
+(define-syntax add-instruction
+  (syntax-rules ()
+    [(_ (name instr ac args ...) b b* ...)
+     (putprop 'name *cogen*
+       (cons (length '(args ...))
+             (lambda (instr ac args ...) b b* ...)))]))
+
+(define-syntax add-instructions
+  (syntax-rules ()
+    [(_ instr ac [(name* arg** ...) b* b** ...] ...)
+     (begin
+       (add-instruction (name* instr ac arg** ...) b* b** ...) ...)]))
+
+(define (convert-instruction a ac)
+  (cond
+    [(getprop (car a) *cogen*) =>
+     (lambda (p)
+       (let ([n (car p)] [proc (cdr p)] [args (cdr a)])
+         (cond
+           [(fx= n (length args))
+            (apply proc a ac args)]
+           [else 
+            (error 'convert-instruction "incorrect args in ~s" a)])))]
+    [else (old-convert-instruction a ac)]
+    ;[else (error 'convert-instruction "unknown instruction in ~s" a)]
+    ))
+
+(module ()
+(define who 'assembler)
+(add-instructions instr ac
+  [(ret) (CODE #xC3 ac)]
+  [(cltd) (CODE #x99 ac)]
+  [(movl src dst)
+   (cond
+     [(and (imm? src) (reg? dst))  (CODEri #xB8 dst src ac)]
+     [(and (imm? src) (mem? dst))  (CODEdi #xC7 dst src ac)]
+     [(and (reg? src) (reg? dst))  (CODErr #x89 src dst ac)]
+     [(and (reg? src) (mem? dst))  (CODErd #x89 src dst ac)]
+     [(and (mem? src) (reg? dst))  (CODErd #x8B dst src ac)] 
+     [else (error who "invalid ~s" instr)])]
+   [(movb src dst)
+    (cond
+      ;[(and (imm8? src) (reg8? dst))  (CODEri #xB0 dst src ac)]
+      [(and (imm8? src) (mem? dst)) (CODEdi8 #xC6 dst src ac)]
+      ;[(and (reg8? src) (reg8? dst))  (CODErr #x88 src dst ac)]
+      [(and (reg8? src) (mem? dst))   (CODErd #x88 src dst ac)]
+      [(and (mem? src) (reg8? dst))   (CODErd #x8A dst src ac)] 
+      [else (error who "invalid ~s" instr)])]
+   [(addl src dst)
+    (cond   
+      ;;; add imm -> reg
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/0 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x05 (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/0 dst (IMM32 src ac)))]
+      ;;; add reg -> reg
+      [(and (reg? src) (reg? dst))
+       (CODE #x01 (ModRM 3 src dst ac))]
+      ;;; add mem -> reg
+      [(and (mem? src) (reg? dst))
+       (CODErd #x03 dst src ac)]
+      ;;; add imm -> mem (not needed)
+      ;;; add reg -> mem (not needed)
+      [else (error who "invalid ~s" instr)])]
+   [(subl src dst)
+    (cond   
+      ;;; imm -> reg
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/5 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x2D (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/5 dst (IMM32 src ac)))]
+      ;;; reg -> reg
+      [(and (reg? src) (reg? dst))
+       (CODE #x29 (ModRM 3 src dst ac))]
+      ;;; mem -> reg
+      [(and (mem? src) (reg? dst))
+       (CODErd #x2B dst src ac)]
+      ;;; imm -> mem (not needed)
+      ;;; reg -> mem (not needed)
+      [else (error who "invalid ~s" instr)])]
+   [(sall src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/4 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/4 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/4 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(shrl src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/5 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/5 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/5 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(sarl src dst)
+        (cond
+          [(and (equal? '(int 1) src) (reg? dst))
+           (CODE #xD1 (ModRM 3 '/7 dst ac))]
+          [(and (imm8? src) (reg? dst))
+           (CODE #xC1 (ModRM 3 '/7 dst (IMM8 src ac)))]
+          [(and (eq? src '%cl) (reg? dst))
+           (CODE #xD3 (ModRM 3 '/7 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(andl src dst) 
+        (cond
+          ;;; and imm -> reg
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/4 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x25 (IMM32 src ac))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x81 (ModRM 3 '/4 dst (IMM32 src ac)))]
+          ;;; and reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x21 (ModRM 3 src dst ac))]
+          ;;; and mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x23 dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(orl src dst) 
+        (cond
+          ;;; or imm -> reg
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/1 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x0D (IMM32 src ac))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x81 (ModRM 3 '/1 dst (IMM32 src ac)))]
+          ;;; or reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x09 (ModRM 3 src dst ac))]
+          ;;; or mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x0B dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(xorl src dst) 
+        (cond
+          ;;; or imm -> reg
+          ;[(and (imm8? src) (reg? dst)) 
+          ; (CODE #x83 (ModRM 3 '/1 dst (IMM8 src ac)))]
+          ;[(and (imm? src) (eq? dst '%eax)) 
+          ; (CODE #x0D (IMM32 src ac))]
+          ;[(and (imm? src) (reg? dst))
+          ; (CODE #x81 (ModRM 3 '/1 dst (IMM32 src ac)))]
+          ;;; or reg -> reg
+          [(and (reg? src) (reg? dst))
+           (CODE #x31 (ModRM 3 src dst ac))]
+          ;;; or mem -> reg
+          [(and (mem? src) (reg? dst))
+           (CODErd #x33 dst src ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(cmpl src dst)
+        (cond
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x83 (ModRM 3 '/7 dst (IMM8 src ac)))]
+          [(and (imm? src) (eq? dst '%eax)) 
+           (CODE #x3D (IMM32 src ac))]
+          [(and (reg? src) (reg? dst))
+           (CODE #x39 (ModRM 3 src dst ac))]
+          [(and (mem? src) (reg? dst))
+           (CODErd #x3B dst src ac)]
+          [(and (imm8? src) (mem? dst))
+           (CODErd #x83 '/7 dst (IMM8 src ac))]
+          [(and (imm? src) (mem? dst))
+           (CODErd #x81 '/7 dst (IMM32 src ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(imull src dst)
+        (cond
+          [(and (imm8? src) (reg? dst)) 
+           (CODE #x6B (ModRM 3 dst dst (IMM8 src ac)))]
+          [(and (imm? src) (reg? dst))
+           (CODE #x69 (ModRM 3 dst dst (IMM32 src ac)))]
+          [(and (reg? src) (reg? dst))
+           (CODE #x0F (CODE #xAF (ModRM 3 dst src ac)))]
+          [(and (mem? src) (reg? dst))
+           (CODE #x0F (CODErd #xAF dst src ac))]
+          [else (error who "invalid ~s" instr)])]
+   [(idivl dst)
+        (cond
+          [(reg? dst)
+           (CODErr #xF7 '/7 dst ac)]
+          [(mem? dst)
+           (CODErd #xF7 '/7 dst ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(pushl dst)
+        (cond
+          [(imm8? dst) 
+           (CODE #x6A (IMM8 dst ac))]
+          [(imm? dst)
+           (CODE #x68 (IMM32 dst ac))]
+          [(reg? dst)
+           (CODE+r #x50 dst ac)]
+          [(mem? dst)
+           (CODErd #xFF '/6 dst ac)]
+          [else (error who "invalid ~s" instr)])] 
+   [(popl dst)
+        (cond
+          [(reg? dst)
+           (CODE+r #x58 dst ac)]
+          [(mem? dst)
+           (CODErd #x8F '/0 dst ac)]
+          [else (error who "invalid ~s" instr)])] 
+   [(notl dst)
+        (cond
+          [(reg? dst)
+           (CODE #xF7 (ModRM 3 '/2 dst ac))]
+          [(mem? dst)
+           (CODErd #xF7 '/7 dst ac)]
+          [else (error who "invalid ~s" instr)])]
+   [(negl dst)
+        (cond
+          [(reg? dst)
+           (CODE #xF7 (ModRM 3 '/3 dst ac))]
+          [else (error who "invalid ~s" instr)])]
+))
+
+(define old-convert-instruction
+  (lambda (a ac)
+    (define who 'assemble)
+    (check-len a)
+    (case (car a)
+      [(jmp)
+       (with-args a
+         (lambda (dst)
+           (cond
+             [(label? dst)
+              (CODE #xE9 (cons (cons 'relative (label-name dst)) ac))]
+             [(imm? dst) 
+              (CODE #xE9 (IMM32 dst ac))]
+             [(mem? dst)
+              (CODErd #xFF '/4 dst ac)]
+             [else (error who "invalid jmp in ~s" a)])))]
+      [(call)
+       (with-args a
+         (lambda (dst)
+           (cond
+             [(imm? dst) 
+              (CODE #xE8 (IMM32 dst ac))]
+             [(label? dst)
+              (CODE #xE8 (cons (cons 'relative (label-name dst)) ac))]
+             [(mem? dst)
+              (CODErd #xFF '/2 dst ac)]
+             [(reg? dst)
+              (CODE #xFF (ModRM 3 '/2 dst ac))]
+             [else (error who "invalid jmp in ~s" a)])))]
+      [(seta  setae  setb  setbe  sete  setg  setge  setl  setle
+        setna setnae setnb setnbe setne setng setnge setnl setnle)
+       (let* ([table
+               '([seta  #x97] [setna  #x96] 
+                 [setae #x93] [setnae #x92]
+                 [setb  #x92] [setnb  #x93]
+                 [setbe #x96] [setnbe #x97]
+                 [setg  #x9F] [setng  #x9E]
+                 [setge #x9D] [setnge #x9C]
+                 [setl  #x9C] [setnl  #x9D]
+                 [setle #x9E] [setnle #x9F]
+                 [sete  #x94] [setne  #x95])]
+              [lookup
+               (lambda (x)
+                 (cond
+                   [(assq x table) => cadr]
+                   [else (error who "invalid cset ~s" x)]))])
+         (with-args a
+           (lambda (dst)
+             (cond
+               [(reg8? dst)
+                (CODE #x0F 
+                  (CODE (lookup (car a)) 
+                    (ModRM 3 '/0 dst ac)))]
+               [else (error who "invalid ~s" a)]))))]
+      [(ja  jae  jb  jbe  je  jg  jge  jl  jle
+        jna jnae jnb jnbe jne jng jnge jnl jnle)
+       (let* ([table 
+               '([je #x84]  [jne #x85]
+                 [ja #x87]  [jna #x86]
+                 [jae #x83] [jnae #x82] 
+                 [jb #x82]  [jnb #x83]
+                 [jbe #x86] [jnbe #x87] 
+                 [jg #x8F]  [jng #x8E] 
+                 [jge #x8D] [jnge #x8C]
+                 [jl #x8C]  [jnl #x8D]
+                 [jle #x8E] [jnle #x8F])]
+              [lookup
+               (lambda (x)
+                 (cond
+                   [(assq x table) => cadr]
+                   [else (error who "invalid cmp ~s" x)]))])
+         (with-args a
+           (lambda (dst)
+             (cond
+               [(imm? dst)
+                (CODE #x0F (CODE (lookup (car a)) (IMM32 dst ac)))]
+               [(label? dst)
+                (CODE #x0F 
+                  (CODE (lookup (car a)) 
+                    (cons (cons 'relative (label-name dst)) ac)))]
+               [else (error who "invalid ~s" a)]))))]
+      [(byte) 
+       (with-args a
+         (lambda (x)
+           (unless (byte? x) (error who "invalid instruction ~s" a))
+           (cons (byte x) ac)))]
+      [(byte-vector)
+       (with-args a
+         (lambda (x) (append (map byte (vector->list x)) ac)))]
+      [(int) (IMM32 a ac)] 
+      [(label)
+       (with-args a 
+         (lambda (L)
+           (unless (symbol? L) (error who "invalid instruction ~s" a))
+           (cons (cons 'label L) ac)))]
+      [(label-address)
+       (with-args a 
+         (lambda (L)
+           (unless (symbol? L) (error who "invalid instruction ~s" a))
+           (cons (cons 'label-addr L) ac)))]
+      [(current-frame-offset)
+       (cons '(current-frame-offset) ac)]
+      [(nop) ac]
+      [else
+       (error who "unknown instruction ~s" a)])))
+
+(define diff
+  (lambda (ls x)
+    (cond
+      [(eq? ls x) '()]
+      [else (cons (car ls) (diff (cdr ls) x))])))
+
+(define hex-table
+  '#(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7
+     #\8 #\9 #\A #\B #\C #\D #\E #\F))
+
+(define write/x
+  (lambda (x)
+    (case (car x)
+      [(byte)
+       (display "0x")
+       (display (vector-ref hex-table (fxsra (cdr x) 4)))
+       (display (vector-ref hex-table (fxlogand (cdr x) 15)))
+       (display " ")]
+      [else (write x)])))
+
+
+(define compute-code-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (case (car x)
+              [(byte) (fx+ ac 1)]
+              [(word reloc-word reloc-word+ label-addr foreign-label 
+                relative current-frame-offset)
+               (fx+ ac 4)]
+              [(label) ac]
+              [else (error 'compute-code-size "unknown instr ~s" x)]))
+          0 
+          ls)))
+
+
+(define set-label-loc!
+  (lambda (x loc)
+    (when (getprop x '*label-loc*)
+      (error 'compile "label ~s is already defined" x))
+    (putprop x '*label-loc* loc)))
+
+(define label-loc
+  (lambda (x)
+    (or (getprop x '*label-loc*)
+        (error 'compile "undefined label ~s" x))))
+
+
+(define unset-label-loc!
+  (lambda (x)
+    (remprop x '*label-loc*)))
+
+
+(define set-code-word!
+  (lambda (code idx x)
+    (cond
+      [(fixnum? x) 
+       (code-set! code (fx+ idx 0) (fxsll (fxlogand x #x3F) 2))
+       (code-set! code (fx+ idx 1) (fxlogand (fxsra x 6) #xFF))
+       (code-set! code (fx+ idx 2) (fxlogand (fxsra x 14) #xFF))
+       (code-set! code (fx+ idx 3) (fxlogand (fxsra x 22) #xFF))]
+      [else (error 'set-code-word! "unhandled ~s" x)])))
+ 
+(define whack-instructions
+  (lambda (x ls)
+    (define f
+      (lambda (ls idx reloc)
+        (cond
+          [(null? ls) reloc]
+          [else
+           (let ([a (car ls)])
+             (case (car a)
+               [(byte) 
+                (code-set! x idx (cdr a))
+                (f (cdr ls) (fx+ idx 1) reloc)]
+               [(reloc-word reloc-word+)
+                (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+               [(relative label-addr foreign-label) 
+                (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+               [(word)
+                (let ([v (cdr a)])
+                   (set-code-word! x idx v)
+                   (f (cdr ls) (fx+ idx 4) reloc))]
+               [(current-frame-offset)
+                (set-code-word! x idx idx)
+                (f (cdr ls) (fx+ idx 4) reloc)]
+               [(label)
+                (set-label-loc! (cdr a) (cons x idx))
+                (f (cdr ls) idx reloc)]
+               [else
+                (error 'whack-instructions "unknown instr ~s" a)]))])))
+    (f ls 0 '())))
+
+(define wordsize 4)
+
+
+(define compute-reloc-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (case (car x)
+              [(reloc-word foreign-label)        (fx+ ac 2)]
+              [(relative reloc-word+ label-addr) (fx+ ac 3)]
+              [(word byte label current-frame-offset)    ac]
+              [else (error 'compute-reloc-size "unknown instr ~s" x)]))
+          0 
+          ls)))
+
+(define whack-reloc
+  (lambda (vec)
+    (define reloc-idx 0)
+    (lambda (r)
+      (let ([idx (car r)] [type (cadr r)] [v (cddr r)])
+        (case type
+          [(reloc-word)
+           (vector-set! vec reloc-idx (fxsll idx 2))
+           (vector-set! vec (fx+ reloc-idx 1) v)
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(foreign-label)
+           (vector-set! vec reloc-idx (fxlogor 1 (fxsll idx 2)))
+           (vector-set! vec (fx+ reloc-idx 1) v)
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(reloc-word+)
+           (let ([obj (car v)] [disp (cdr v)])
+             (vector-set! vec reloc-idx (fxlogor 2 (fxsll idx 2)))
+             (vector-set! vec (fx+ reloc-idx 1) disp)
+             (vector-set! vec (fx+ reloc-idx 2) obj)
+             (set! reloc-idx (fx+ reloc-idx 3)))]
+          [(label-addr)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [disp (cdr loc)])
+               (vector-set! vec reloc-idx (fxlogor 2 (fxsll idx 2)))
+               (vector-set! vec (fx+ reloc-idx 1) (fx+ disp 11))
+               (vector-set! vec (fx+ reloc-idx 2) obj)))
+           (set! reloc-idx (fx+ reloc-idx 3))]
+          [(relative)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [disp (cdr loc)])
+               (vector-set! vec reloc-idx (fxlogor 3 (fxsll idx 2)))
+               (vector-set! vec (fx+ reloc-idx 1) (fx+ disp 11))
+               (vector-set! vec (fx+ reloc-idx 2) obj)))
+           (set! reloc-idx (fx+ reloc-idx 3))]
+          [else (error 'whack-reloc "invalid reloc type ~s" type)]))
+      )))
+
+
+;;; (define list->code
+;;;   (lambda (ls)
+;;;     (let ([ls (convert-instructions ls)])
+;;;       (let ([n (compute-code-size ls)]
+;;;             [m (compute-reloc-size ls)])
+;;;         (let ([x (make-code n m 1)])
+;;;           (let ([reloc* (whack-instructions x ls)])
+;;;             (for-each (whack-reloc x) reloc*))
+;;;           (make-code-executable! x)
+;;;           x)))))
+
+(define list*->code*
+  (lambda (ls*)
+    (let ([closure-size* (map car ls*)]
+          [ls* (map cdr ls*)])
+      (let ([ls* (map convert-instructions ls*)])
+        (let ([n* (map compute-code-size ls*)]
+              [m* (map compute-reloc-size ls*)])
+          (let ([code* (map make-code n* closure-size*)]
+                [relv* (map make-vector m*)])
+            (let ([reloc** (map whack-instructions code* ls*)])
+              (for-each
+                (lambda (relv reloc*)
+                  (for-each (whack-reloc relv) reloc*))
+                relv* reloc**)
+              (for-each set-code-reloc-vector! code* relv*)
+              code*)))))))
+
+(define list->code
+  (lambda (ls)
+    (car (list*->code* (list ls)))))
+
+(primitive-set! 'list*->code* list*->code*)
+)
diff --git a/src/libintelasm-6.9.ss b/src/libintelasm-6.9.ss
new file mode 100644
index 0000000..74ccc3c
--- /dev/null
+++ b/src/libintelasm-6.9.ss
@@ -0,0 +1,887 @@
+
+;;; 
+;;; assuming the existence of a code manager, this file defines an assember
+;;; that takes lists of assembly code and produces a list of code objects
+;;;
+
+   ;;;      add     
+   ;;;      and
+   ;;;      cmp
+   ;;;      call
+   ;;;      cltd
+   ;;;      idiv
+   ;;;      imull
+   ;;;      ja
+   ;;;      jae
+   ;;;      jb
+   ;;;      jbe
+   ;;;      je
+   ;;;      jg
+   ;;;      jge
+   ;;;      jl
+   ;;;      jle
+   ;;;      jne
+   ;;;      jmp
+   ;;;      movb
+   ;;;      movl
+   ;;;      negl
+   ;;;      notl
+   ;;;      orl
+   ;;;      popl
+   ;;;      pushl
+   ;;;      ret
+   ;;;      sall
+   ;;;      sarl
+   ;;;      shrl
+   ;;;      sete
+   ;;;      setg
+
+
+(let ()
+
+(define fold
+  (lambda (f init ls)
+    (cond
+      [(null? ls) init]
+      [else
+       (f (car ls) (fold f init (cdr ls)))])))
+
+(define convert-instructions
+  (lambda (ls)
+    (fold convert-instruction '() ls)))
+
+(define register-mapping
+  '([%eax 32 0] 
+    [%ecx 32 1]
+    [%edx 32 2]
+    [%ebx 32 3]
+    [%esp 32 4]
+    [%ebp 32 5]
+    [%esi 32 6]
+    [%edi 32 7]
+    [%al   8 0]
+    [%cl   8 1]
+    [%dl   8 2]
+    [%bl   8 3]
+    [%ah   8 4]
+    [%ch   8 5]
+    [%dh   8 6]
+    [%bh   8 7]
+    [/0   0  0]
+    [/1   0  1]
+    [/2   0  2]
+    [/3   0  3]
+    [/4   0  4]
+    [/5   0  5]
+    [/6   0  6]
+    [/7   0  7]
+    ))
+  
+(define register-index
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) => caddr]
+      [else (error 'register-index "not a register ~s" x)])))
+
+(define reg32?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 32))]
+      [else #f])))
+
+(define reg8?
+  (lambda (x)
+    (cond
+      [(assq x register-mapping) =>
+       (lambda (x) (fx= (cadr x) 8))]
+      [else #f])))
+
+(define reg?
+  (lambda (x)
+    (assq x register-mapping)))
+
+
+;(define with-args
+;  (lambda (ls f)
+;    (apply f (cdr ls))))
+
+(define-syntax with-args
+  (syntax-rules (lambda)
+    [(_ x (lambda (a0 a1) b b* ...))
+     (let ([t x])
+       (if (pair? t) 
+           (let ([t ($cdr t)])
+             (if (pair? t)
+                 (let ([a0 ($car t)] [t ($cdr t)])
+                   (if (pair? t)
+                        (let ([a1 ($car t)])
+                           (if (null? ($cdr t)) 
+                               (let () b b* ...)
+                               (error 'with-args "too many args")))
+                        (error 'with-args "too few args")))
+                 (error 'with-args "too few args")))
+           (error 'with-args "too few args")))]))
+
+
+;(define byte
+;  (lambda (x)
+;    (cons 'byte (fxlogand x 255))))
+
+(define-syntax byte
+  (syntax-rules ()
+    [(_ x) (fxlogand x 255)]))
+
+
+(define word
+  (lambda (x)
+    (cons 'word x)))
+
+(define reloc-word
+  (lambda (x)
+    (cons 'reloc-word x)))
+
+(define reloc-word+
+  (lambda (x d)
+    (list* 'reloc-word+ x d)))
+
+(define byte?
+  (lambda (x)
+    (and (fixnum? x)
+         (fx<= x 127)
+         (fx<= -128 x))))
+
+(define mem?
+  (lambda (x)
+    (and (list? x)
+         (fx= (length x) 3)
+         (eq? (car x) 'disp)
+         (or (imm? (cadr x))
+             (reg? (cadr x)))
+         (or (imm? (caddr x))
+             (reg? (caddr x))))))
+
+(define small-disp?
+  (lambda (x)
+    (and (mem? x)
+         (byte? (cadr x)))))
+
+
+(define CODE
+  (lambda (n ac)
+    (cons (byte n) ac)))
+
+(define CODE+r
+  (lambda (n r ac)
+    (cons (byte (fxlogor n (register-index r))) ac)))
+
+(define ModRM
+  (lambda (mod reg r/m ac)
+    (cons (byte (fxlogor 
+                  (register-index r/m)
+                  (fxlogor 
+                    (fxsll (register-index reg) 3)
+                    (fxsll mod 6))))
+          (if (and (not (fx= mod 3)) (eq? r/m '%esp))
+              (cons (byte #x24) ac)
+              ac))))
+
+(define IMM32
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n)
+           (byte (fxsra n  8))
+           (byte (fxsra n 16))
+           (byte (fxsra n 24))
+           ac))]
+      [(obj? n)
+       (let ([v (cadr n)])
+         (if (immediate? v)
+             (cons (word v) ac)
+             (cons (reloc-word v) ac)))]
+      [(obj+? n)
+       (let ([v (cadr n)] [d (caddr n)])
+         (cons (reloc-word+ v d) ac))]
+      [(label-address? n)
+       (cons (cons 'label-addr (label-name n)) ac)]
+      [(foreign? n)
+       (cons (cons 'foreign-label (label-name n)) ac)]
+      [else (error 'IMM32 "invalid ~s" n)])))
+
+
+(define IMM8
+  (lambda (n ac)
+    (cond
+      [(int? n) 
+       (let ([n (cadr n)])
+         (list* (byte n) ac))]
+      [else (error 'IMM8 "invalid ~s" n)])))
+
+
+(define imm?
+  (lambda (x)
+    (or (int? x)
+        (obj? x)
+        (obj+? x) 
+        (label-address? x)
+        (foreign? x))))
+
+(define foreign?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'foreign-label))))
+
+
+(define imm8?
+  (lambda (x)
+    (and (int? x) (byte? (cadr x)))))
+
+(define label?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (symbol? (car d)))
+           (error 'assemble "invalid label ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-address?
+  (lambda (x)
+    (cond
+      [(and (pair? x) (eq? (car x) 'label-address))
+       (let ([d (cdr x)])
+         (unless (and (null? (cdr d))
+                      (or (symbol? (car d))
+                          (string? (car d))))
+           (error 'assemble "invalid label-address ~s" x)))
+       #t]
+      [else #f])))
+
+(define label-name
+  (lambda (x) (cadr x)))
+
+(define int?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'int))))
+
+(define obj?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj))))
+
+(define obj+?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'obj+))))
+
+(define CODErri
+  (lambda (c d s i ac)
+    (cond
+      [(imm8? i)
+       (CODE c (ModRM 1 d s (IMM8 i ac)))]
+      [(imm? i)
+       (CODE c (ModRM 2 d s (IMM32 i ac)))]
+      [else (error 'CODErri "invalid i=~s" i)])))
+
+(define CODErr
+  (lambda (c d s ac)
+    (CODE c (ModRM 3 d s ac))))
+
+(define CODEri
+  (lambda (c d i ac)
+    (CODE+r c d (IMM32 i ac))))
+
+
+(define RegReg
+  (lambda (r1 r2 r3 ac)
+    (cond
+      [(eq? r3 '%esp) (error 'assembler "BUG: invalid src %esp")]
+      [(eq? r1 '%ebp) (error 'assembler "BUG: invalid src %ebp")]
+      [else 
+       (list*
+         (byte (fxlogor 4 (fxsll (register-index r1) 3)))
+         (byte (fxlogor (register-index r2) 
+                        (fxsll (register-index r3) 3)))
+         ac)])))
+
+
+;;(define CODErd
+;;  (lambda (c r1 disp ac)
+;;    (with-args disp
+;;      (lambda (i/r r2)
+;;        (if (reg? i/r)
+;;            (CODE c (RegReg r1 i/r r2 ac))
+;;            (CODErri c r1 r2 i/r ac))))))
+
+
+(define IMM32*2
+  (lambda (i1 i2 ac)
+    (cond
+      [(and (int? i1) (obj? i2))
+       (let ([d (cadr i1)] [v (cadr i2)])
+         (cons (reloc-word+ v d) ac))]
+      [else (error 'assemble "IMM32*2 ~s ~s" i1 i2)])))
+
+
+(define CODErd
+  (lambda (c r1 disp ac)
+    (with-args disp
+      (lambda (a1 a2)
+        (cond
+          [(and (reg? a1) (reg? a2))
+           (CODE c (RegReg r1 a1 a2 ac))]
+          [(and (imm? a1) (reg? a2))
+           (CODErri c r1 a2 a1 ac)]
+          [(and (imm? a1) (imm? a2))
+           (CODE c 
+             (ModRM 0 r1 '/5 
+               (IMM32*2 a1 a2 ac)))]
+          [else (error 'CODErd "unhandled ~s" disp)])))))
+
+;;; (define CODEdi
+;;;   (lambda (c disp n ac)
+;;;     (with-args disp
+;;;       (lambda (i r)
+;;;         (CODErri c '/0 r i (IMM32 n ac))))))
+
+(define CODEdi
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (a1 a2)
+        (cond
+          [(and (reg? a1) (reg? a2)) 
+           (error 'CODEdi "unsupported1")]
+          [(and (imm? a1) (reg? a2))
+           (CODErri c '/0 a2 a1 (IMM32 n ac))]
+          [(and (imm? a1) (imm? a2))
+           (error 'CODEdi "unsupported2")]
+          [else (error 'CODEdi "unhandled ~s" disp)])))))
+
+
+(define CODEdi8
+  (lambda (c disp n ac)
+    (with-args disp
+      (lambda (i r)
+        (CODErri c '/0 r i (IMM8 n ac))))))
+
+(define *cogen* (gensym "*cogen*"))
+
+(define-syntax add-instruction
+  (syntax-rules ()
+    [(_ (name instr ac args ...) b b* ...)
+     (putprop 'name *cogen*
+       (cons (length '(args ...))
+             (lambda (instr ac args ...) b b* ...)))]))
+
+(define-syntax add-instructions
+  (syntax-rules ()
+    [(_ instr ac [(name* arg** ...) b* b** ...] ...)
+     (begin
+       (add-instruction (name* instr ac arg** ...) b* b** ...) ...)]))
+
+(define (convert-instruction a ac)
+  (cond
+    [(getprop (car a) *cogen*) =>
+     (lambda (p)
+       (let ([n (car p)] [proc (cdr p)] [args (cdr a)])
+         (cond
+           [(fx= n 2)
+            (if (fx= (length args) 2)
+                (proc a ac (car args) (cadr args))
+                (error 'convert-instruction "incorrect args in ~s" a))]
+           [(fx= n 1)
+            (if (fx= (length args) 1)
+                (proc a ac (car args))
+                (error 'convert-instruction "incorrect args in ~s" a))]
+           [(fx= n 0)
+            (if (fx= (length args) 0)
+                (proc a ac)
+                (error 'convert-instruction "incorrect args in ~s" a))] 
+           [else
+            (if (fx= (length args) n)
+                (apply proc a ac args)
+                (error 'convert-instruction "incorrect args in ~s" a))])))]
+    [else (error 'convert-instruction "unknown instruction in ~s" a)]))
+
+;;; instr/null is for 1-byte instructions that take no arguments
+;(define (instr/null code ac)
+;  (cons code ac))
+
+;(define (instr/ir arg1 arg2 ac ircode)
+;  (CODE+r ircode arg2 (IMM32 arg1 ac)))
+;
+;(define (instr/im arg1 arg2 ac imcode)
+;  (error 'instr/im "not implemented"))
+;
+;(define (instr/rr arg1 arg2 ac rrcode)
+;  (CODErr rrcode arg1 arg2 ac))
+;
+;(define (instr/rm arg1 arg2 ac rmcode)
+;  (CODErd rmcode arg1 arg2 ac))
+
+
+(define (instr/2 arg1 arg2 ac ircode imcode rrcode rmcode mrcode)
+  (cond
+    [(imm? arg1)
+     (cond
+       [(reg? arg2) (CODEri ircode arg2 arg1 ac)]
+       [(mem? arg2) (CODEdi imcode arg2 arg1 ac)]
+       [else (error 'instr/2 "invalid args ~s ~s" arg1 arg2)])]
+    [(reg? arg1)
+     (cond
+       [(reg? arg2) (CODErr rrcode arg1 arg2 ac)]
+       [(mem? arg2) (CODErd rmcode arg1 arg2 ac)]
+       [else (error 'instr/2 "invalid args ~s ~s" arg1 arg2)])]
+    [(mem? arg1)
+     (cond
+       [(reg? arg2) (CODErd mrcode arg2 arg1 ac)]
+       [else (error 'instr/2 "invalid args ~s ~s" arg1 arg2)])]
+    [else (error 'instr/2 "invalid args ~s ~s" arg1 arg2)]))
+
+(module ()
+(define who 'assembler)
+
+(define (conditional-set c dst ac)
+  (cond
+    [(reg8? dst)
+     (CODE #x0F (CODE c (ModRM 3 '/0 dst ac)))]
+    [else (error who "invalid condition-set to ~s" dst)]))
+
+(define (conditional-jump c dst ac)
+  (cond
+    [(imm? dst)
+     (CODE #x0F (CODE c (IMM32 dst ac)))]
+    [(label? dst)
+     (CODE #x0F (CODE c (cons (cons 'relative (label-name dst)) ac)))]
+    [else (error who "invalid conditional jump target ~s" dst)]))
+
+(add-instructions instr ac
+   [(ret)  (CODE #xC3 ac)]
+   [(cltd) (CODE #x99 ac)]
+   [(movl src dst) (instr/2 src dst ac #xB8 #xC7 #x89 #x89 #x8B)]
+   [(movb src dst)
+    (cond
+      [(and (imm8? src) (mem? dst)) (CODEdi8 #xC6 dst src ac)]
+      [(and (reg8? src) (mem? dst)) (CODErd #x88 src dst ac)]
+      [(and (mem? src) (reg8? dst)) (CODErd #x8A dst src ac)] 
+      [else (error who "invalid ~s" instr)])]
+   [(addl src dst)
+    (cond   
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/0 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x05 (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/0 dst (IMM32 src ac)))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x01 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x03 dst src ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(subl src dst)
+    (cond   
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/5 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x2D (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/5 dst (IMM32 src ac)))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x29 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x2B dst src ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(sall src dst)
+    (cond
+      [(and (equal? '(int 1) src) (reg? dst))
+       (CODE #xD1 (ModRM 3 '/4 dst ac))]
+      [(and (imm8? src) (reg? dst))
+       (CODE #xC1 (ModRM 3 '/4 dst (IMM8 src ac)))]
+      [(and (eq? src '%cl) (reg? dst))
+       (CODE #xD3 (ModRM 3 '/4 dst ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(shrl src dst)
+    (cond
+      [(and (equal? '(int 1) src) (reg? dst))
+       (CODE #xD1 (ModRM 3 '/5 dst ac))]
+      [(and (imm8? src) (reg? dst))
+       (CODE #xC1 (ModRM 3 '/5 dst (IMM8 src ac)))]
+      [(and (eq? src '%cl) (reg? dst))
+       (CODE #xD3 (ModRM 3 '/5 dst ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(sarl src dst)
+    (cond
+      [(and (equal? '(int 1) src) (reg? dst))
+       (CODE #xD1 (ModRM 3 '/7 dst ac))]
+      [(and (imm8? src) (reg? dst))
+       (CODE #xC1 (ModRM 3 '/7 dst (IMM8 src ac)))]
+      [(and (eq? src '%cl) (reg? dst))
+       (CODE #xD3 (ModRM 3 '/7 dst ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(andl src dst) 
+    (cond
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/4 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x25 (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/4 dst (IMM32 src ac)))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x21 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x23 dst src ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(orl src dst) 
+    (cond
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/1 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x0D (IMM32 src ac))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x81 (ModRM 3 '/1 dst (IMM32 src ac)))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x09 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x0B dst src ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(xorl src dst) 
+    (cond
+      [(and (reg? src) (reg? dst))
+       (CODE #x31 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x33 dst src ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(cmpl src dst)
+    (cond
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x83 (ModRM 3 '/7 dst (IMM8 src ac)))]
+      [(and (imm? src) (eq? dst '%eax)) 
+       (CODE #x3D (IMM32 src ac))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x39 (ModRM 3 src dst ac))]
+      [(and (mem? src) (reg? dst))
+       (CODErd #x3B dst src ac)]
+      [(and (imm8? src) (mem? dst))
+       (CODErd #x83 '/7 dst (IMM8 src ac))]
+      [(and (imm? src) (mem? dst))
+       (CODErd #x81 '/7 dst (IMM32 src ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(imull src dst)
+    (cond
+      [(and (imm8? src) (reg? dst)) 
+       (CODE #x6B (ModRM 3 dst dst (IMM8 src ac)))]
+      [(and (imm? src) (reg? dst))
+       (CODE #x69 (ModRM 3 dst dst (IMM32 src ac)))]
+      [(and (reg? src) (reg? dst))
+       (CODE #x0F (CODE #xAF (ModRM 3 dst src ac)))]
+      [(and (mem? src) (reg? dst))
+       (CODE #x0F (CODErd #xAF dst src ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(idivl dst)
+    (cond
+      [(reg? dst)
+       (CODErr #xF7 '/7 dst ac)]
+      [(mem? dst)
+       (CODErd #xF7 '/7 dst ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(pushl dst)
+    (cond
+      [(imm8? dst) 
+       (CODE #x6A (IMM8 dst ac))]
+      [(imm? dst)
+       (CODE #x68 (IMM32 dst ac))]
+      [(reg? dst)
+       (CODE+r #x50 dst ac)]
+      [(mem? dst)
+       (CODErd #xFF '/6 dst ac)]
+      [else (error who "invalid ~s" instr)])] 
+   [(popl dst)
+    (cond
+      [(reg? dst)
+       (CODE+r #x58 dst ac)]
+      [(mem? dst)
+       (CODErd #x8F '/0 dst ac)]
+      [else (error who "invalid ~s" instr)])] 
+   [(notl dst)
+    (cond
+      [(reg? dst)
+       (CODE #xF7 (ModRM 3 '/2 dst ac))]
+      [(mem? dst)
+       (CODErd #xF7 '/7 dst ac)]
+      [else (error who "invalid ~s" instr)])]
+   [(negl dst)
+    (cond
+      [(reg? dst)
+       (CODE #xF7 (ModRM 3 '/3 dst ac))]
+      [else (error who "invalid ~s" instr)])]
+   [(jmp dst)
+    (cond
+      [(label? dst)
+       (CODE #xE9 (cons (cons 'relative (label-name dst)) ac))]
+      [(imm? dst) 
+       (CODE #xE9 (IMM32 dst ac))]
+      [(mem? dst)
+       (CODErd #xFF '/4 dst ac)]
+      [else (error who "invalid jmp target ~s" dst)])]
+   [(call dst)
+    (cond
+      [(imm? dst) 
+       (CODE #xE8 (IMM32 dst ac))]
+      [(label? dst)
+       (CODE #xE8 (cons (cons 'relative (label-name dst)) ac))]
+      [(mem? dst)
+       (CODErd #xFF '/2 dst ac)]
+      [(reg? dst)
+       (CODE #xFF (ModRM 3 '/2 dst ac))]
+      [else (error who "invalid jmp target ~s" dst)])]
+   [(seta dst)   (conditional-set #x97 dst ac)]
+   [(setae dst)  (conditional-set #x93 dst ac)]
+   [(setb dst)   (conditional-set #x92 dst ac)]
+   [(setbe dst)  (conditional-set #x96 dst ac)]
+   [(setg dst)   (conditional-set #x9F dst ac)]
+   [(setge dst)  (conditional-set #x9D dst ac)]
+   [(setl dst)   (conditional-set #x9C dst ac)]
+   [(setle dst)  (conditional-set #x9E dst ac)]
+   [(sete dst)   (conditional-set #x94 dst ac)]
+   [(setna dst)  (conditional-set #x96 dst ac)]
+   [(setnae dst) (conditional-set #x92 dst ac)]
+   [(setnb dst)  (conditional-set #x93 dst ac)]
+   [(setnbe dst) (conditional-set #x97 dst ac)]
+   [(setng dst)  (conditional-set #x9E dst ac)]
+   [(setnge dst) (conditional-set #x9C dst ac)]
+   [(setnl dst)  (conditional-set #x9D dst ac)]
+   [(setnle dst) (conditional-set #x9F dst ac)]
+   [(setne dst)  (conditional-set #x95 dst ac)]
+   [(ja dst)   (conditional-jump #x87 dst ac)]
+   [(jae dst)  (conditional-jump #x83 dst ac)]
+   [(jb dst)   (conditional-jump #x82 dst ac)]
+   [(jbe dst)  (conditional-jump #x86 dst ac)]
+   [(jg dst)   (conditional-jump #x8F dst ac)]
+   [(jge dst)  (conditional-jump #x8D dst ac)]
+   [(jl dst)   (conditional-jump #x8C dst ac)]
+   [(jle dst)  (conditional-jump #x8E dst ac)]
+   [(je dst)   (conditional-jump #x84 dst ac)]
+   [(jna dst)  (conditional-jump #x86 dst ac)]
+   [(jnae dst) (conditional-jump #x82 dst ac)]
+   [(jnb dst)  (conditional-jump #x83 dst ac)]
+   [(jnbe dst) (conditional-jump #x87 dst ac)]
+   [(jng dst)  (conditional-jump #x8E dst ac)]
+   [(jnge dst) (conditional-jump #x8C dst ac)]
+   [(jnl dst)  (conditional-jump #x8D dst ac)]
+   [(jnle dst) (conditional-jump #x8F dst ac)]
+   [(jne dst)  (conditional-jump #x85 dst ac)]
+   [(byte x)
+    (unless (byte? x) (error who "~s is not a byte" x))
+    (cons (byte x) ac)]
+   [(byte-vector x) (append (map (lambda (x) (byte x)) (vector->list x)) ac)]
+   [(int a) (IMM32 instr ac)]
+   [(label L)
+    (unless (symbol? L) (error who "label ~s is not a symbol" L))
+    (cons (cons 'label L) ac)]
+   [(label-address L)
+    (unless (symbol? L) (error who "label-address ~s is not a symbol" L))
+    (cons (cons 'label-addr L) ac)]
+   [(current-frame-offset)
+    (cons '(current-frame-offset) ac)]
+   [(nop) ac]
+))
+
+
+(define compute-code-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (if (fixnum? x)
+                (fx+ ac 1)
+                (case (car x)
+                  [(byte) (fx+ ac 1)]
+                  [(word reloc-word reloc-word+ label-addr foreign-label 
+                    relative local-relative current-frame-offset)
+                   (fx+ ac 4)]
+                  [(label) ac]
+                  [else (error 'compute-code-size "unknown instr ~s" x)])))
+          0 
+          ls)))
+
+
+(define set-label-loc!
+  (lambda (x loc)
+    (when (getprop x '*label-loc*)
+      (error 'compile "label ~s is already defined" x))
+    (putprop x '*label-loc* loc)))
+
+(define label-loc
+  (lambda (x)
+    (or (getprop x '*label-loc*)
+        (error 'compile "undefined label ~s" x))))
+
+
+(define unset-label-loc!
+  (lambda (x)
+    (remprop x '*label-loc*)))
+
+
+(define set-code-word!
+  (lambda (code idx x)
+    (cond
+      [(fixnum? x) 
+       (code-set! code (fx+ idx 0) (fxsll (fxlogand x #x3F) 2))
+       (code-set! code (fx+ idx 1) (fxlogand (fxsra x 6) #xFF))
+       (code-set! code (fx+ idx 2) (fxlogand (fxsra x 14) #xFF))
+       (code-set! code (fx+ idx 3) (fxlogand (fxsra x 22) #xFF))]
+      [else (error 'set-code-word! "unhandled ~s" x)])))
+ 
+(define (optimize-local-jumps ls)
+  (define locals '())
+  (define g (gensym))
+  (for-each
+    (lambda (x)
+      (when (and (pair? x) (eq? (car x) 'label))
+        (putprop (cdr x) g 'local)
+        (set! locals (cons (cdr x) locals))))
+    ls)
+  (for-each
+    (lambda (x)
+      (when (and (pair? x)
+                 (eq? (car x) 'relative)
+                 (eq? (getprop (cdr x) g) 'local))
+        (set-car! x 'local-relative)))
+    ls)
+  (for-each (lambda (x) (remprop x g)) locals)
+  ls)
+
+
+
+(define whack-instructions
+  (lambda (x ls)
+    (define f
+      (lambda (ls idx reloc)
+        (cond
+          [(null? ls) reloc]
+          [else
+           (let ([a (car ls)])
+             (if (fixnum? a)
+                 (begin
+                   (code-set! x idx a)
+                   (f (cdr ls) (fxadd1 idx) reloc))
+                 (case (car a)
+                  [(byte) 
+                   (code-set! x idx (cdr a))
+                   (f (cdr ls) (fx+ idx 1) reloc)]
+                  [(reloc-word reloc-word+)
+                   (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+                  [(local-relative relative label-addr foreign-label) 
+                   (f (cdr ls) (fx+ idx 4) (cons (cons idx a) reloc))]
+                  [(word)
+                   (let ([v (cdr a)])
+                      (set-code-word! x idx v)
+                      (f (cdr ls) (fx+ idx 4) reloc))]
+                  [(current-frame-offset)
+                   (set-code-word! x idx idx)
+                   (f (cdr ls) (fx+ idx 4) reloc)]
+                  [(label)
+                   (set-label-loc! (cdr a) (cons x idx))
+                   (f (cdr ls) idx reloc)]
+                  [else
+                   (error 'whack-instructions "unknown instr ~s" a)])))])))
+    (f ls 0 '())))
+
+(define wordsize 4)
+
+
+(define compute-reloc-size 
+  (lambda (ls)
+    (fold (lambda (x ac)
+            (if (fixnum? x)
+                ac
+                (case (car x)
+                  [(reloc-word foreign-label)        (fx+ ac 2)]
+                  [(relative reloc-word+ label-addr) (fx+ ac 3)]
+                  [(word byte label current-frame-offset local-relative)    ac]
+                  [else (error 'compute-reloc-size "unknown instr ~s" x)])))
+          0 
+          ls)))
+
+(define whack-reloc
+  (lambda (code vec)
+    (define reloc-idx 0)
+    (lambda (r)
+      (let ([idx (car r)] [type (cadr r)] [v (cddr r)])
+        (case type
+          [(reloc-word)
+           (vector-set! vec reloc-idx (fxsll idx 2))
+           (vector-set! vec (fx+ reloc-idx 1) v)
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(foreign-label)
+           (vector-set! vec reloc-idx (fxlogor 1 (fxsll idx 2)))
+           (vector-set! vec (fx+ reloc-idx 1) v)
+           (set! reloc-idx (fx+ reloc-idx 2))]
+          [(reloc-word+)
+           (let ([obj (car v)] [disp (cdr v)])
+             (vector-set! vec reloc-idx (fxlogor 2 (fxsll idx 2)))
+             (vector-set! vec (fx+ reloc-idx 1) disp)
+             (vector-set! vec (fx+ reloc-idx 2) obj)
+             (set! reloc-idx (fx+ reloc-idx 3)))]
+          [(label-addr)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [disp (cdr loc)])
+               (vector-set! vec reloc-idx (fxlogor 2 (fxsll idx 2)))
+               (vector-set! vec (fx+ reloc-idx 1) (fx+ disp 11))
+               (vector-set! vec (fx+ reloc-idx 2) obj)))
+           (set! reloc-idx (fx+ reloc-idx 3))]
+          [(local-relative)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [disp (cdr loc)])
+               (unless (eq? obj code)
+                 (error 'whack-reloc "local-relative differ"))
+               (let ([rel (fx- disp (fx+ idx 4))])
+                 (code-set! code (fx+ idx 0) (fxlogand rel #xFF))
+                 (code-set! code (fx+ idx 1) (fxlogand (fxsra rel 8) #xFF))
+                 (code-set! code (fx+ idx 2) (fxlogand (fxsra rel 16) #xFF))
+                 (code-set! code (fx+ idx 3) (fxlogand (fxsra rel 24) #xFF)))))]
+          [(relative)
+           (let ([loc (label-loc v)])
+             (let ([obj (car loc)] [disp (cdr loc)])
+               (vector-set! vec reloc-idx (fxlogor 3 (fxsll idx 2)))
+               (vector-set! vec (fx+ reloc-idx 1) (fx+ disp 11))
+               (vector-set! vec (fx+ reloc-idx 2) obj)))
+           (set! reloc-idx (fx+ reloc-idx 3))]
+          [else (error 'whack-reloc "invalid reloc type ~s" type)]))
+      )))
+
+
+;;; (define list->code
+;;;   (lambda (ls)
+;;;     (let ([ls (convert-instructions ls)])
+;;;       (let ([n (compute-code-size ls)]
+;;;             [m (compute-reloc-size ls)])
+;;;         (let ([x (make-code n m 1)])
+;;;           (let ([reloc* (whack-instructions x ls)])
+;;;             (for-each (whack-reloc x) reloc*))
+;;;           (make-code-executable! x)
+;;;           x)))))
+
+(define list*->code*
+  (lambda (ls*)
+    (let ([closure-size* (map car ls*)]
+          [ls* (map cdr ls*)])
+      (let* ([ls* (map convert-instructions ls*)]
+             [ls* (map optimize-local-jumps ls*)])
+        (let ([n* (map compute-code-size ls*)]
+              [m* (map compute-reloc-size ls*)])
+          (let ([code* (map make-code n* closure-size*)]
+                [relv* (map make-vector m*)])
+            (let ([reloc** (map whack-instructions code* ls*)])
+              (for-each
+                (lambda (foo reloc*)
+                  (for-each (whack-reloc (car foo) (cdr foo)) reloc*))
+                (map cons code* relv*) reloc**)
+              (for-each set-code-reloc-vector! code* relv*)
+              code*)))))))
+
+(define list->code
+  (lambda (ls)
+    (car (list*->code* (list ls)))))
+
+(primitive-set! 'list*->code* list*->code*)
+)
diff --git a/src/libinterpret-6.5.ss b/src/libinterpret-6.5.ss
new file mode 100644
index 0000000..f064d7b
--- /dev/null
+++ b/src/libinterpret-6.5.ss
@@ -0,0 +1,324 @@
+
+;;; Changes:
+;;; 6.5: handles letrec
+;;; 6.1: adding case-lambda, dropping lambda
+;;; 6.0: basic version working
+;;;
+
+;;; Expand : Scheme -> Core Scheme 
+;;;
+;;; <CS> ::= (quote datum)
+;;;        | <gensym>
+;;;        | (if <CS> <CS> <CS>)
+;;;        | (set! <gensym> <CS>)
+;;;        | (begin <CS> <CS> ...)
+;;;        | (case-lambda (<FML> <CS>) (<FML> <CS>) ...)
+;;;        | (<prim> <CS> <CS> ...)
+;;;        | (primref <primname>)
+;;;        | (<CS> <CS> ...)
+;;; <FML> ::= ()
+;;;         | <gensym>
+;;;         | (<gensym> . <FML>)
+;;; <prim> ::= void | memv | top-level-value | set-top-level-value!
+;;;
+
+
+(let ()
+  (define syntax-error
+    (lambda (x)
+      (error 'interpret "invalid syntax ~s" x)))
+  ;;;
+  (define C*->last
+    (lambda (a d env)
+      (cond
+        [(null? d) (C a env)]
+        [else
+         (let ([a (C a env)]
+               [d (C*->last (car d) (cdr d) env)])
+           (lambda (renv)
+             (a renv)
+             (d renv)))])))
+  ;;;
+  (define C*->list
+    (lambda (a d env)
+      (cond
+        [(null? d) 
+         (let ([a (C a env)])
+           (lambda (renv)
+             (list (a renv))))]
+        [else
+         (let ([a (C a env)]
+               [d (C*->list (car d) (cdr d) env)])
+           (lambda (renv)
+             (cons (a renv) (d renv))))])))
+  ;;;
+  (define extend-env
+    (lambda (fml* env)
+      (cons fml* env)))
+  ;;;
+  (define fml-length
+    (lambda (fml* x)
+      (cond
+        [(pair? fml*) (fxadd1 (fml-length (cdr fml*) x))]
+        [(null? fml*) 0]
+        [(symbol? fml*) 1]
+        [else (syntax-error x)])))
+  ;;;
+  (define whack-proper
+    (lambda (v ls i j)
+      (cond
+        [(null? ls) 
+         (if (fx= i j)
+             v
+             (error 'apply1 "incorrect number of arguments to procedure"))]
+        [(fx= i j)
+         (error 'apply2 "incorrect number of arguments to procedure")]
+        [else
+         (vector-set! v i (car ls))
+         (whack-proper v (cdr ls) (fxadd1 i) j)])))
+  ;;;
+  (define whack-improper
+    (lambda (v ls i j)
+      (cond
+        [(fx= i j) (vector-set! v i ls) v]
+        [(null? ls) 
+         (error 'apply3 "incorrect number of arguments to procedure")]
+        [else
+         (vector-set! v i (car ls))
+         (whack-improper v (cdr ls) (fxadd1 i) j)])))
+  ;;;
+  (define lookup
+    (lambda (x env)
+      (define Lj
+        (lambda (x fml* j)
+          (cond
+            [(pair? fml*) 
+             (if (eq? (car fml*) x)
+                 j
+                 (Lj x (cdr fml*) (fxadd1 j)))]
+            [(eq? x fml*) j]
+            [else #f])))
+      (define Li
+        (lambda (x env i)
+          (cond
+            [(null? env) #f]
+            [(Lj x (car env) 0) =>
+             (lambda (j)
+               (cons i j))]
+            [else (Li x (cdr env) (fxadd1 i))])))
+      (Li x env 0)))
+  ;;;
+  (define C
+    (lambda (x env)
+      (cond
+        [(gensym? x) 
+         (cond
+           [(lookup x env) =>
+            (lambda (b)
+              (let ([i (car b)] [j (cdr b)])
+                (lambda (renv)
+                  (vector-ref (list-ref renv i) j))))]
+           [else (syntax-error x)])]
+        [(pair? x)
+         (let ([a (car x)] [d (cdr x)])
+           (unless (list? d) (syntax-error x))
+           (cond 
+             [(eq? a 'quote) 
+              (unless (fx= (length d) 1) (syntax-error x))
+              (let ([v (car d)])
+                (lambda (renv) v))]
+             [(eq? a 'if) 
+              (unless (fx= (length d) 3) (syntax-error x))
+              (let ([test   (C (car d) env)] 
+                    [conseq (C (cadr d) env)]
+                    [altern (C (caddr d) env)])
+                (lambda (renv)
+                  (if (test renv)
+                      (conseq renv)
+                      (altern renv))))]
+             [(eq? a 'set!)
+              (unless (fx= (length d) 2) (syntax-error x))
+              (let ([var (car d)] [val (C (cadr d) env)])
+                (cond
+                  [(lookup var env) =>
+                   (lambda (b)
+                     (let ([i (car b)] [j (cdr b)])
+                       (lambda (renv)
+                         (vector-set! (list-ref renv i) j (val renv)))))]
+                  [else (syntax-error x)]))]
+             [(eq? a 'begin)
+              (unless (fx>= (length d) 1) (syntax-error x))
+              (C*->last (car d) (cdr d) env)]
+             [(eq? a 'letrec)
+              (let ([bind* (car d)] [body* (cdr d)])
+                (if (null? bind*)
+                    (C*->last (car body*) (cdr body*) env)
+                    (let ([lhs* (map car bind*)] [rhs* (map cadr bind*)])
+                      (let ([env (extend-env lhs* env)])
+                        (let ([body* (C*->last (car body*) (cdr body*) env)]
+                              [rhs* (C*->list (car rhs*) (cdr rhs*) env)]
+                              [n (length lhs*)])
+                          (lambda (renv)
+                            (let ([v (make-vector n)])
+                              (let ([renv (cons v renv)])
+                                (let f ([i 0] [ls (rhs* renv)])
+                                  (if (null? ls)
+                                      (body* renv)
+                                      (begin
+                                        (vector-set! v i (car ls))
+                                        (f (fxadd1 i) (cdr ls))))))))
+                          )))))]
+             [(eq? a 'case-lambda)
+              (unless (fx>= (length d) 1) (syntax-error x))
+              (let ()
+                (define generate
+                  (lambda (d)
+                    (cond
+                      [(null? d) 
+                       (lambda (n args renv)
+                         (error 'apply 
+                                "incorrect number of arguments ~s to procedure"
+                                n))]
+                      [else
+                       (let ([k (generate (cdr d))]
+                             [a (car d)])
+                         (let ([fml (car a)] [body* (cdr a)])
+                           (let ([env (extend-env fml env)]
+                                 [n (fml-length fml x)])
+                             (let ([body*
+                                    (C*->last (car body*) (cdr body*) env)])
+                               (if (list? fml)
+                                   (lambda (m args renv)
+                                     (if (fx= n m)
+                                         (body* (cons (list->vector args) renv))
+                                         (k m args renv)))
+                                   (let ([q (fxsub1 n)])
+                                     (lambda (m args renv)
+                                       (if (fx>= m q)
+                                         (let ([v (make-vector n)])
+                                           (let f ([i 0] [args args])
+                                             (cond
+                                               [(fx= i q)
+                                                (vector-set! v q args)]
+                                               [else
+                                                (vector-set! v i (car args))
+                                                (f (fxadd1 i) (cdr args))]))
+                                           (body* (cons v renv)))
+                                         (k m args renv)))))))))])))
+                (let ([dispatch (generate d)])
+                  (lambda (renv)
+                    (lambda args
+                      (dispatch (length args) args renv)))))]
+             [(eq? a 'void)
+              (unless (fx= (length d) 0) (syntax-error x))
+              (lambda (renv) (void))]
+             [(eq? a 'memv)
+              (unless (fx= (length d) 2) (syntax-error x))
+              (let ([val (C (car d) env)] [list (C (cadr d) env)])
+                (lambda (renv)
+                  (memq (val renv) (list renv))))]
+             [(eq? a 'top-level-value)
+              (unless (fx= (length d) 1) (syntax-error x))
+              (let ([qsym (car d)])
+                (unless (and (pair? qsym)
+                             (fx= (length qsym) 2)
+                             (eq? (car qsym) 'quote)
+                             (symbol? (cadr qsym)))
+                  (syntax-error x))
+                (let ([sym (cadr qsym)])
+                  (if (top-level-bound? sym)
+                      (lambda (renv) 
+                        (top-level-value sym))
+                      (lambda (renv)
+                        (if (top-level-bound? sym)
+                            (top-level-value sym)
+                            (error #f "~s is unbound" sym))))))]
+             [(memq a '(set-top-level-value!))
+              (unless (fx= (length d) 2) (syntax-error x))
+              (let ([qsym (car d)] [val (C (cadr d) env)])
+                (unless (and (pair? qsym)
+                             (fx= (length qsym) 2)
+                             (eq? (car qsym) 'quote)
+                             (symbol? (cadr qsym)))
+                  (syntax-error x))
+                (let ([sym (cadr qsym)])
+                  (lambda (renv) 
+                    (set-top-level-value! sym (val renv)))))]
+             ;;; [(eq? a '$pcb-set!)
+             ;;;  (unless (fx= (length d) 2) (syntax-error x))
+             ;;;  (let ([sym (car d)] [val (C (cadr d) env)])
+             ;;;    (unless (symbol? sym) (syntax-error x))
+             ;;;    (lambda (renv) 
+             ;;;      (set-top-level-value! sym (val renv))))] 
+             [(eq? a '|#primitive|)
+              (unless (fx= (length d) 1) (syntax-error x))
+              (let ([sym (car d)])
+                (let ([prim (primitive-ref sym)])
+                  (if (procedure? prim)
+                      (lambda (renv) prim)
+                      (syntax-error x))))]
+             [(memq a '(foreign-call $apply))
+              (error 'interpret "~a form is not supported" a)]
+         ;;; [else
+         ;;;  (let ([rator (C a env)] [n (length d)])
+         ;;;    (cond 
+         ;;;      [(fx= n 0) 
+         ;;;       (lambda (renv)
+         ;;;         (let ([p (rator renv)])
+         ;;;           (p)))]
+         ;;;      [(fx= n 1) 
+         ;;;       (let ([arg1 (C (car d) env)])
+         ;;;         (lambda (renv)
+         ;;;           (let ([p (rator renv)])
+         ;;;             (p (arg1 renv)))))]
+         ;;;      [(fx= n 2)
+         ;;;       (let ([arg1 (C (car d) env)]
+         ;;;             [arg2 (C (cadr d) env)])
+         ;;;         (lambda (renv)
+         ;;;           (let ([p (rator renv)])
+         ;;;             (p (arg1 renv) (arg2 renv)))))]
+         ;;;      [else
+         ;;;       (let ([arg* (C*->list (car d) (cdr d) env)])
+         ;;;         (lambda (renv)
+         ;;;           (apply (rator renv) (arg* renv))))]))]
+             [else
+              (let ([rator (C a env)] [n (length d)])
+                (cond 
+                  [(fx= n 0) 
+                   (lambda (renv)
+                     (apply (rator renv) '()))]
+                  ;[(fx= n 1) 
+                  ; (let ([arg1 (C (car d) env)])
+                  ;   (lambda (renv)
+                  ;     ((rator renv) (arg1 renv))))]
+                  ;[(fx= n 2)
+                  ; (let ([arg1 (C (car d) env)]
+                  ;       [arg2 (C (cadr d) env)])
+                  ;   (lambda (renv)
+                  ;     ((rator renv) (arg1 renv) (arg2 renv))))]
+                  [else
+                   (let ([arg* (C*->list (car d) (cdr d) env)])
+                     (lambda (renv)
+                       (apply (rator renv) (arg* renv))))]))]
+             
+             ))]
+        [else (syntax-error x)])))
+  ;;;
+  (primitive-set! 'interpret
+    (lambda (x)
+      (let ([x (expand x)])
+        (let ([p (C x '())])
+          (p '())))))
+  ;;;
+  (primitive-set! 'current-eval
+    (make-parameter 
+      interpret
+      (lambda (f)
+        (unless (procedure? f)
+          (error 'current-eval "~s is not a procedure" f))
+        f)))
+  ;;;
+  (primitive-set! 'eval
+    (lambda (x)
+      ((current-eval) x))))
+
diff --git a/src/libinterpret.fasl b/src/libinterpret.fasl
index 1a7af32..d167d41 100644
Binary files a/src/libinterpret.fasl and b/src/libinterpret.fasl differ
diff --git a/src/libio-6.9.ss b/src/libio-6.9.ss
new file mode 100644
index 0000000..216fb60
--- /dev/null
+++ b/src/libio-6.9.ss
@@ -0,0 +1,407 @@
+
+;;; OUTPUT PORTS
+  
+(let ()
+   ;;; only file-based ports are supported at this point
+   ;;;
+   ;;; an output port is a vector with the following fields:
+   ;;; 0. id
+   ;;; 1. file-name
+   ;;; 2. file-descriptor
+   ;;; 3. open?
+   ;;; 4. buffer
+   ;;; 5. buffer-size
+   ;;; 6. index
+   ;;; 7. flush-proc
+   ;;; 8. close-proc
+   (define-record output-port 
+      (name fd open? 
+       buffer size index flush-proc close-proc))
+   (define fd->port
+     (lambda (fd filename)
+       (make-output-port filename fd #t
+         (make-string 4096) 4096 0
+         fd-flush-proc fd-close-proc)))
+   (define open-output-string
+     (lambda ()
+       (make-output-port '*string-port* '() #t
+         (make-string 4096) 4096 0
+         str-flush-proc (lambda (port) (void)))))
+   (define get-output-string
+     (lambda (p)
+       (define fill
+         (lambda (dst src di si sj)
+           (cond
+             [(fx= si sj) dst]
+             [else
+              (string-set! dst di (string-ref src si))
+              (fill dst src (fxadd1 di) (fxadd1 si) sj)])))
+       (unless (output-port? p) 
+         (error 'get-output-string "~s is not an output port" p))
+       (let ([ls (output-port-fd p)])
+         (unless (list? ls)
+           (error 'get-output-string "~s is not an output port" p))
+         (let f ([ls (reverse ls)] [n 0])
+           (cond
+             [(null? ls) 
+              (let ([idx (output-port-index p)]
+                    [buf (output-port-buffer p)])
+                (let ([str (make-string (fx+ n idx))])
+                  (fill str buf n 0 idx)))]
+             [else
+              (let ([buf (car ls)])
+                (let ([idx (string-length buf)])
+                  (let ([str (f (cdr ls) (fx+ n idx))])
+                    (fill str buf n 0 idx))))])))))
+   (define open-output-file
+     (lambda (name mode)
+       (unless (string? name)
+         (error 'open-output-file "~s is not a valid file name" name))
+       (let ([mode 
+              (cond
+               [(assq mode '([error 0] [append 1] [replace 2] [truncate 3]))
+                => cadr]
+               [else
+                (error 'open-output-file "~s is not a valid mode" mode)])])
+        (let ([fh (foreign-call "ik_open_file" name mode)])
+          (fd->port fh name)))))
+   (define write-char
+     (lambda (c port)
+       (unless (char? c)
+         (error 'write-char "not a char: ~s" c))
+       (unless (output-port-open? port)
+         (error 'write-char "port ~s closed" port))
+       (let ([idx (output-port-index port)] [size (output-port-size port)])
+          (if (fx< idx size)
+              (begin 
+                (string-set! (output-port-buffer port) idx c)
+                (set-output-port-index! port (fxadd1 idx))
+                (when ($char= c #\newline)
+                  (flush-output-port port)))
+              (begin 
+                (flush-output-port port)
+                (write-char c port))))))
+   (define fd-flush-proc
+     (lambda (port)
+       (let ([idx (output-port-index port)])
+         (when (fx> idx 0)
+           (foreign-call "ik_write" 
+                          (output-port-fd port)
+                          idx
+                          (output-port-buffer port))))
+        (set-output-port-index! port 0)))
+   (define str-flush-proc
+     (lambda (port)
+       (let ([idx (output-port-index port)])
+         (when (fx> idx 0)
+           (let ([str (output-port-buffer port)])
+             (when (fx= idx (string-length str))
+               (set-output-port-fd! port
+                 (cons str (output-port-fd port)))
+               (set-output-port-buffer! port
+                  (make-string (string-length str)))
+               (set-output-port-index! port 0)))))))
+   (define fd-close-proc
+     (lambda (port)
+       (let ([idx (output-port-index port)])
+         (when (fx> idx 0)
+           (foreign-call "ik_write" 
+                          (output-port-fd port)
+                          idx
+                          (output-port-buffer port))))
+         (foreign-call "ik_close" (output-port-fd port))))
+
+   (define flush-output-port
+     (lambda (port)
+       (unless (output-port-open? port)
+         (error 'flush-output-port "port ~s closed" port))
+       ((output-port-flush-proc port) port)))
+   (define close-output-port
+     (lambda (port)
+       (when (output-port-open? port)
+         ((output-port-close-proc port) port)
+         (set-output-port-open?! port #f))))
+          
+   ;;; init section
+   (primitive-set! 'close-output-port 
+     (case-lambda
+       [() (close-output-port (current-output-port))]
+       [(p) 
+        (unless (output-port? p)
+          (error 'close-output-port "~s is not an output port" p))
+        (close-output-port p)]))
+   (primitive-set! 'output-port? output-port?)
+   (primitive-set! 'open-output-file 
+     (case-lambda
+       [(filename) (open-output-file filename 'error)]
+       [(filename mode) (open-output-file filename mode)]))
+   (primitive-set! 'write-char 
+     (case-lambda
+       [(c) (write-char c (current-output-port))]
+       [(c p) 
+        (unless (output-port? p)
+          (error 'write-char "~s is not an output port" p))
+        (write-char c p)]))
+   (primitive-set! 'flush-output-port 
+     (case-lambda
+       [() (flush-output-port (current-output-port))]
+       [(p) 
+        (unless (output-port? p)
+          (error 'flush-output-port "~s is not an output port" p))
+        (flush-output-port p)]))
+   (primitive-set! 'standard-output-port
+     (let ([p (fd->port 1 '*stdout*)])
+       (lambda () p)))
+   (primitive-set! 'standard-error-port
+     (let ([p (fd->port 2 '*stderr*)])
+       (lambda () p)))
+   (primitive-set! 'current-output-port
+     (make-parameter (standard-output-port)
+       (lambda (p)
+         (unless (output-port? p)
+           (error 'current-output-port "not a port ~s" p))
+         p)))
+   (primitive-set! 'console-output-port
+     (make-parameter (standard-output-port)
+       (lambda (p)
+         (unless (output-port? p)
+           (error 'console-output-port "not a port ~s" p))
+         p)))
+   (primitive-set! 'newline
+     (case-lambda 
+       [() (write-char #\newline (current-output-port))]
+       [(p)
+        (unless (output-port? p)
+          (error 'newline "~s is not an output port" p))
+        (write-char #\newline p)]))
+
+   (primitive-set! 'open-output-string open-output-string)
+   (primitive-set! 'get-output-string get-output-string)
+   (primitive-set! 'output-port-name
+     (lambda (x)
+       (if (output-port? x)
+           (output-port-name x)
+           (error 'output-port-name "~s is not an output port" x)))))
+
+;;; INPUT PORTS
+
+(let ()
+  ;;; input ports are similar to output ports, with the exception of
+  ;;; the ungetchar buffer
+  ;;; Fields:
+  ;;; 0. id
+  ;;; 1. file-name
+  ;;; 2. file-descriptor
+  ;;; 3. open?
+  ;;; 4. buffer
+  ;;; 5. buffer-size
+  ;;; 6. index
+  ;;; 7. unget
+  (define-record input-port
+      (name fd open? buffer size index returned-char))
+  (define fd->port
+    (lambda (fd filename)
+      (make-input-port filename fd #t (make-string 4096) 0 0 #f)))
+  (define open-input-file
+    (lambda (filename)
+      (unless (string? filename)
+        (error 'open-input-file "not a string: ~s" filename))
+      (let ([fd (foreign-call "ik_open_file" filename 4)])
+        (fd->port fd filename))))
+  (define close-input-port
+    (lambda (port)
+      (foreign-call "ik_close" (input-port-fd port))
+      (set-input-port-open?! port #f)
+      (set-input-port-returned-char! port #f)
+      (set-input-port-index! port (input-port-size port))))
+  (define read-char
+    (lambda (port)
+      (if (input-port-returned-char port)
+          (let ([c (input-port-returned-char port)])
+            (set-input-port-returned-char! port #f)
+            c)
+          (let ([index (input-port-index port)])
+            (if ($fx< index (input-port-size port))
+                (begin
+                  (set-input-port-index! port ($fxadd1 index))
+                  ($string-ref (input-port-buffer port) index))
+                (if (input-port-open? port)
+                    (let* ([buffer (input-port-buffer port)]
+                           [bytes 
+                            (foreign-call "ik_read" 
+                                (input-port-fd port)
+                                buffer
+                                ($string-length buffer))])
+                      (set-input-port-size! port bytes)
+                      (if ($fxzero? bytes)
+                          (begin 
+                            (set-input-port-index! port 0)
+                            (eof-object))
+                          (let ([c ($string-ref buffer 0)])
+                             (set-input-port-index! port 1)
+                             c)))
+                    (error 'read-char "input port ~s is not open" port)))))))
+  (define peek-char
+    (lambda (port)
+      (unless (input-port-open? port)
+        (error 'peek-char "port closed"))
+      (cond
+        [(input-port-returned-char port) =>
+         (lambda (c) c)]
+        [else 
+         (let ([idx (input-port-index port)]
+               [size (input-port-size port)]
+               [buf (input-port-buffer port)])
+           (if (fx< idx size)
+               (string-ref buf idx)
+               (let ([bytes 
+                      (foreign-call "ik_read" 
+                         (input-port-fd port)
+                         buf
+                         ($string-length buf))])
+                 (set-input-port-size! port bytes)
+                 (set-input-port-index! port 0)
+                 (if (fxzero? bytes)
+                     (eof-object)
+                     (string-ref buf 0)))))])))
+  (define reset-input-port!
+    (lambda (p)
+      (unless (input-port? p)
+        (error 'reset-input-port! "~s is not an input port" p))
+      (set-input-port-index! p 0)
+      (set-input-port-size! p 0)
+      (set-input-port-returned-char! p #f)))
+  (define unread-char
+    (lambda (c port)
+      (unless (char? c)
+        (error 'unread-char "not a character ~s" c))
+      (unless (input-port-open? port)
+        (error 'unread-char "port closed"))
+      (when (input-port-returned-char port)
+        (error 'unread-char "cannot unread twice"))
+      (set-input-port-returned-char! port c)))
+  (define *current-input-port* #f)
+  (primitive-set! 'open-input-file open-input-file)
+  (primitive-set! 'close-input-port 
+    (case-lambda
+      [() (close-input-port *current-input-port*)]
+      [(p)
+       (unless (input-port? p) 
+         (error 'close-input-port "~s is not an input port" p))
+       (close-input-port p)]))
+  (primitive-set! 'input-port? input-port?)
+  (primitive-set! 'read-char 
+    (case-lambda
+      [()  (read-char *current-input-port*)]
+      [(p) (if (input-port? p)
+               (read-char p)
+               (error 'read-char "~s is not an input-port" p))]))
+  (primitive-set! 'peek-char 
+    (case-lambda
+      [() (peek-char *current-input-port*)]
+      [(p)
+       (unless (input-port? p) 
+         (error 'peek-char "~s is not an input port" p))
+       (peek-char p)]))
+  (primitive-set! 'unread-char
+    (case-lambda
+      [(c) (unread-char c *current-input-port*)]
+      [(c p)
+       (unless (input-port? p) 
+         (error 'unread-char "~s is not an input port" p))
+       (unread-char c p)]))
+  (primitive-set! 'standard-input-port
+    (let ([p (fd->port 0 '*stdin*)])
+      (lambda () p)))
+  (set! *current-input-port* (standard-input-port))
+  (primitive-set! 'current-input-port
+    (case-lambda
+      [() *current-input-port*]
+      [(x) (if (input-port? x)
+               (set! *current-input-port* x)
+               (error 'current-input-port "~s is not an input port" x))]))
+  (primitive-set! 'console-input-port
+    (make-parameter (standard-input-port) 
+      (lambda (x)
+        (unless (input-port? x)
+          (error 'console-input-port "not an input port ~s" x))
+        x)))
+  (primitive-set! 'input-port-name
+    (lambda (x)
+      (if (input-port? x)
+          (input-port-name x)
+          (error 'input-port-name "~s is not an input port" x))))
+  (primitive-set! 'reset-input-port! reset-input-port!))         
+
+(primitive-set! 'with-output-to-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'with-output-to-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'with-output-to-file "~s is not a procedure" proc))
+     (let ([p (apply open-output-file name args)]
+           [shot #f])
+       (parameterize ([current-output-port p])
+         (dynamic-wind 
+           (lambda () 
+             (when shot
+               (error 'with-output-to-file 
+                      "cannot reenter")))
+           proc
+           (lambda () 
+             (close-output-port p)
+             (set! shot #t)))))))
+
+(primitive-set! 'call-with-output-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'call-with-output-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'call-with-output-file "~s is not a procedure" proc))
+     (let ([p (apply open-output-file name args)]
+           [shot #f])
+       (dynamic-wind 
+         (lambda () 
+           (when shot
+             (error 'call-with-output-file "cannot reenter")))
+         (lambda () (proc p))
+         (lambda () 
+           (close-output-port p)
+           (set! shot #t))))))
+
+(primitive-set! 'with-input-from-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'with-input-from-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'with-input-from-file "~s is not a procedure" proc))
+     (let ([p (apply open-input-file name args)]
+           [shot #f])
+       (parameterize ([current-input-port p])
+         (dynamic-wind 
+           (lambda () 
+             (when shot
+               (error 'with-input-from-file 
+                      "cannot reenter")))
+           proc
+           (lambda () 
+             (close-input-port p)
+             (set! shot #t)))))))
+
+(primitive-set! 'call-with-input-file
+   (lambda (name proc . args)
+     (unless (string? name) 
+       (error 'call-with-input-file "~s is not a string" name))
+     (unless (procedure? proc)
+       (error 'call-with-input-file "~s is not a procedure" proc))
+     (let ([p (apply open-input-file name args)]
+           [shot #f])
+       (dynamic-wind 
+         (lambda () 
+           (when shot
+             (error 'call-with-input-file "cannot reenter")))
+         (lambda () (proc p))
+         (lambda () 
+           (close-input-port p)
+           (set! shot #t))))))
+
diff --git a/src/libio.fasl b/src/libio.fasl
index c5205dd..da36080 100644
Binary files a/src/libio.fasl and b/src/libio.fasl differ
diff --git a/src/libnumerics-7.1.ss b/src/libnumerics-7.1.ss
new file mode 100644
index 0000000..26d081c
--- /dev/null
+++ b/src/libnumerics-7.1.ss
@@ -0,0 +1,53 @@
+
+(let ()
+  (define (generic+ a b)
+    (cond
+      [(fixnum? a)
+       (cond
+         [(fixnum? b) (foreign-call "iknum_add_fx_fx" a b)]
+         [(bignum? b) (foreign-call "iknum_add_fx_bn" a b)]
+         [else (error '+ "~s is not a number" b)])]
+      [(bignum? a)
+       (cond
+         [(fixnum? b) (foreign-call "iknum_add_fx_bn" b a)]
+         [(bignum? b) (foreign-call "iknum_add_bn_bn" a b)]
+         [else (error '+ "~s is not a number" b)])]
+      [else (error '+ "~s is not a number" a)]))
+
+  (primitive-set! '+
+    (case-lambda 
+      [(a b) (generic+ a b)]
+      [(a b c) (generic+ a (generic+ b c))]
+      [(a) (if (number? a) a (error '+ "~s is not a number" a))]
+      [() 0]
+      [(a b . rest)
+       (let f ([a a] [b b] [rest rest])
+         (generic+ a
+            (if (null? rest)
+                b
+                (f b ($car rest) ($cdr rest)))))]))
+  
+  (primitive-set! 'add1
+    (lambda (a)
+      (cond
+        [(fixnum? a) 
+         (if ($fx< a (most-positive-fixnum))
+             ($fxadd1 a)
+             (foreign-call "iknum_add_fx_fx" a 1))]
+        [(bignum? a)
+         (foreign-call "iknum_add_fx_bn" 1 a)]
+        [else (error 'add1 "~s is not a number" a)])))
+  
+  (primitive-set! 'sub1
+    (lambda (a)
+      (cond
+        [(fixnum? a) 
+         (if ($fx> a (most-negative-fixnum))
+             ($fxsub1 a)
+             (foreign-call "iknum_add_fx_fx" a -1))]
+        [(bignum? a)
+         (foreign-call "iknum_add_fx_bn" -1 a)]
+        [else (error 'add1 "~s is not a number" a)])))
+
+  )
+
diff --git a/src/librecord-6.4.ss b/src/librecord-6.4.ss
new file mode 100644
index 0000000..bae25c7
--- /dev/null
+++ b/src/librecord-6.4.ss
@@ -0,0 +1,254 @@
+
+
+
+(let ()
+
+  (define rtd?
+    (lambda (x)
+      (and ($record? x)
+           (eq? ($record-rtd x) $base-rtd))))
+
+  (define rtd-name
+    (lambda (rtd)
+      ($record-ref rtd 0)))
+
+  (define rtd-length
+    (lambda (rtd)
+      ($record-ref rtd 1)))
+
+  (define rtd-fields
+    (lambda (rtd)
+      ($record-ref rtd 2)))
+
+  (define rtd-printer
+    (lambda (rtd)
+      ($record-ref rtd 3)))
+
+  (define rtd-symbol
+    (lambda (rtd)
+      ($record-ref rtd 4)))
+
+  (define set-rtd-name!
+    (lambda (rtd name)
+      ($record-set! rtd 0 name)))
+ 
+  (define set-rtd-length!
+    (lambda (rtd n)
+      ($record-set! rtd 1 n)))
+
+  (define set-rtd-fields!
+    (lambda (rtd fields)
+      ($record-set! rtd 2 fields)))
+
+  (define set-rtd-printer!
+    (lambda (rtd printer)
+      ($record-set! rtd 3 printer)))
+   
+  (define set-rtd-symbol!
+    (lambda (rtd symbol)
+      ($record-set! rtd 4 symbol)))
+
+  (define make-rtd
+    (lambda (name fields printer symbol)
+      (let ([rtd ($make-record $base-rtd 5)])
+         ($record-set! rtd 0 name)
+         ($record-set! rtd 1 (length fields))
+         ($record-set! rtd 2 fields)
+         ($record-set! rtd 3 printer)
+         ($record-set! rtd 4 symbol)
+         rtd)))
+
+  (define verify-field
+    (lambda (x)
+      (unless (symbol? x) 
+        (error 'make-record-type "~s is not a valid field name" x))))
+  
+  (define set-fields
+    (lambda (r f* i n)
+      (cond
+        [(null? f*)
+         (if ($fx= i n)
+             r
+             #f)]
+        [($fx< i n)
+         (if (null? f*)
+             #f
+             (begin
+               ($record-set! r i ($car f*))
+               (set-fields r ($cdr f*) ($fxadd1 i) n)))]
+        [else #f])))
+
+  (define make-record-type
+    (lambda (name fields)
+      (unless (string? name)
+        (error 'make-record-type "name must be a string, got ~s" name))
+      (unless (list? fields)
+        (error 'make-record-type "fields must be a list, got ~s" fields))
+      (for-each verify-field fields)
+      (make-rtd name fields #f (gensym name))))
+
+
+  (define record-type-name
+    (lambda (rtd)
+      (unless (rtd? rtd)
+        (error 'record-type-name "~s is not an rtd" rtd))
+      (rtd-name rtd)))
+ 
+
+  (define record-type-symbol
+    (lambda (rtd)
+      (unless (rtd? rtd)
+        (error 'record-type-symbol "~s is not an rtd" rtd))
+      (rtd-symbol rtd)))
+  
+  (define record-type-field-names
+    (lambda (rtd)
+      (unless (rtd? rtd)
+        (error 'record-type-field-names "~s is not an rtd" rtd))
+      (rtd-fields rtd)))
+ 
+
+  (define record-constructor
+    (lambda (rtd)
+      (unless (rtd? rtd)
+        (error 'record-constructor "~s is not an rtd"))
+      (lambda args
+        (let ([n (rtd-length rtd)])
+          (let ([r ($make-record rtd n)])
+            (or (set-fields r args 0 n)
+                (error 'record-constructor 
+                  "incorrect number of arguments to the constructor of ~s" 
+                  rtd)))))))
+  
+  (define record-predicate
+    (lambda (rtd)
+      (unless (rtd? rtd)
+        (error 'record-predicate "~s is not an rtd"))
+      (lambda (x)
+        (and ($record? x)
+             (eq? ($record-rtd x) rtd)))))
+
+  (define field-index 
+    (lambda (i rtd who)
+      (cond
+        [(fixnum? i)
+         (unless (and ($fx>= i 0) ($fx< i (rtd-length rtd)))
+           (error who "~s is out of range for rtd ~s" rtd))
+         i]
+        [(symbol? i)
+         (letrec ([lookup
+                   (lambda (n ls)
+                     (cond
+                       [(null? ls) 
+                        (error who "~s is not a field in ~s" rtd)]
+                       [(eq? i ($car ls)) n]
+                       [else (lookup ($fx+ n 1) ($cdr ls))]))])
+           (lookup 0 (rtd-fields rtd)))]
+        [else (error who "~s is not a valid index" i)])))
+
+  (define record-field-accessor
+    (lambda (rtd i)
+      (unless (rtd? rtd)
+        (error 'record-field-accessor "~s is not an rtd" rtd))
+      (let ([i (field-index i rtd 'record-field-accessor)])
+        (lambda (x)
+          (unless (and ($record? x) 
+                       (eq? ($record-rtd x) rtd))
+            (error 'record-field-accessor "~s is not of type ~s" x rtd))
+          ($record-ref x i)))))
+
+  (define record-field-mutator
+    (lambda (rtd i)
+      (unless (rtd? rtd)
+        (error 'record-field-mutator "~s is not an rtd" rtd))
+      (let ([i (field-index i rtd 'record-field-mutator)])
+        (lambda (x v)
+          (unless (and ($record? x) 
+                       (eq? ($record-rtd x) rtd))
+            (error 'record-field-mutator "~s is not of type ~s" x rtd))
+          ($record-set! x i v)))))
+
+  (define record?
+    (lambda (x . rest)
+      (if (null? rest)
+          ($record? x)
+          (let ([rtd ($car rest)])
+            (unless (null? ($cdr rest))
+              (error 'record? "too many arguments"))
+            (unless (rtd? rtd)
+              (error 'record? "~s is not an rtd"))
+            (and ($record? x)
+                 (eq? ($record-rtd x) rtd))))))
+
+  (define record-rtd
+    (lambda (x)
+      (if ($record? x)
+          ($record-rtd x)
+          (error 'record-rtd "~s is not a record" x))))
+
+  (define record-length
+    (lambda (x)
+      (if ($record? x)
+          (rtd-length ($record-rtd x))
+          (error 'record-length "~s is not a record" x))))
+            
+  (define record-name
+    (lambda (x)
+      (if ($record? x)
+          (rtd-name ($record-rtd x))
+          (error 'record-name "~s is not a record" x))))
+
+  (define record-printer
+    (lambda (x)
+      (if ($record? x)
+          (rtd-printer ($record-rtd x))
+          (error 'record-printer "~s is not a record" x))))
+
+  (define record-ref
+    (lambda (x i)
+      (unless ($record? x) (error 'record-ref "~s is not a record" x))
+      (unless (fixnum? i) (error 'record-ref "~s is not a valid index" i))
+      (let ([n (rtd-length ($record-rtd x))])
+        (unless (and ($fx>= i 0) ($fx< i n))
+          (error 'record-ref "index ~s is out of range for ~s" i x))
+        ($record-ref x i))))
+
+  (define record-set!
+    (lambda (x i v)
+      (unless ($record? x) (error 'record-set! "~s is not a record" x))
+      (unless (fixnum? i) (error 'record-set! "~s is not a valid index" i))
+      (let ([n (rtd-length ($record-rtd x))])
+        (unless (and ($fx>= i 0) ($fx< i n))
+          (error 'record-set! "index ~s is out of range for ~s" i x))
+        ($record-set! x i v))))
+
+  (primitive-set! 'make-record-type make-record-type)
+  (primitive-set! 'record-type-name record-type-name)
+  (primitive-set! 'record-type-symbol record-type-symbol)
+  (primitive-set! 'record-type-field-names record-type-field-names)
+  (primitive-set! 'record-constructor record-constructor)
+  (primitive-set! 'record-predicate record-predicate)
+  (primitive-set! 'record-field-accessor record-field-accessor)
+  (primitive-set! 'record-field-mutator record-field-mutator)
+   
+  (primitive-set! 'record? record?)
+  (primitive-set! 'record-rtd record-rtd)
+  (primitive-set! 'record-type-descriptor record-rtd)
+  (primitive-set! 'record-name record-name)
+  (primitive-set! 'record-printer record-printer)
+  (primitive-set! 'record-length record-length)
+  (primitive-set! 'record-ref record-ref)
+  (primitive-set! 'record-set! record-set!)
+
+  (set-rtd-fields! $base-rtd '(name fields length printer symbol))
+  (set-rtd-name! $base-rtd "base-rtd")
+  (set-rtd-printer! $base-rtd
+    (lambda (x p)
+      (unless (rtd? x)
+        (error 'record-type-printer "not an rtd"))
+      (display "#<" p)
+      (display (rtd-name x) p)
+      (display " rtd>" p)))
+
+  )
+
diff --git a/src/librecord.fasl b/src/librecord.fasl
index f307aef..e69de29 100644
Binary files a/src/librecord.fasl and b/src/librecord.fasl differ
diff --git a/src/libsyncase-6.2.ss b/src/libsyncase-6.2.ss
deleted file mode 100644
index 02fcc6e..0000000
--- a/src/libsyncase-6.2.ss
+++ /dev/null
@@ -1,534 +0,0 @@
-
-;;; 6.2: initial syncase implementation
-;;;
-
-
-;;; Expand : Scheme -> Core Scheme 
-;;;
-;;; <CS> ::= (quote datum)
-;;;        | <gensym>
-;;;        | (if <CS> <CS> <CS>)
-;;;        | (set! <gensym> <CS>)
-;;;        | (begin <CS> <CS> ...)
-;;;        | (letrec ([<gensym> <CS>] ...) <CS> <CS> ...)
-;;;        | (lambda <FMLS> <CS> <CS> ...)
-;;;        | (<prim> <CS> <CS> ...)
-;;;        | (#primitive| <primname>)
-;;;        | (<CS> <CS> ...)
-;;; <FML> ::= ()
-;;;         | <gensym>
-;;;         | (<gensym> . <FML>)
-;;; <prim> ::= void | memv | top-level-value | set-top-level-value! 
-;;;          | primitive-set! | foreign-call | $apply
-
-(let ([*stx* (make-record-type "*stx*" '(e marks ribcage))]
-      [*rib* (make-record-type "*rib*" '(sym* marks* lab*))]
-      [*top* (make-record-type "*top*" '())])
-
-  (define stx? (record-predicate *stx*))
-  (define make-stx (record-constructor *stx*))
-  (define stx-e (record-field-accessor *stx* 'e))
-  (define stx-marks (record-field-accessor *stx* 'marks))
-  (define stx-ribcage (record-field-accessor *stx* 'ribcage))
-  (define make-rib (record-constructor *rib*))
-  (define rib-sym* (record-field-accessor *rib* 'sym*))
-  (define rib-marks* (record-field-accessor *rib* 'marks*))
-  (define rib-lab* (record-field-accessor *rib* 'lab*))
-  (define *top-ribcage* ((record-constructor *top*)))
-  (define (top? x) (eq? x *top-ribcage*))
-  (define *syncase-macro* (gensym "*syncase-macro*"))
-
-  (define (build-data x)            `(quote ,x))
-  (define (build-global-ref x)      `(top-level-value ',x))
-  (define (build-lexical-ref x)     x)
-  (define (build-app a d)           `(,a . ,d))
-  (define (build-lambda fml* body)
-    (cond
-      [(and (pair? body) (eq? (car body) 'begin))
-       `(lambda ,fml* . ,(cdr body))]
-      [else 
-       `(lambda ,fml* ,body)]))
-  (define (build-begin body*)       `(begin . ,body*))
-
-
-  (define (build-void)              `(void))
-  (define (build-if e0 e1 e2)       `(if ,e0 ,e1 ,e2))
-  (define (build-foreign-call e e*) `(foreign-call ,e ,e*))
-
-
-
-  (define (id? x) 
-    (and (stx? x)
-         (symbol? (stx-e x))))
-
-  (define (stx->datum x) ;;;; use strip
-    (cond
-      [(stx? x) (stx-e x)]
-      [else     x]))
-
-  (define (stx-pair? x)
-    (and (stx? x)
-         (pair? (stx-e x))))
-
-  (define (strip x)
-    (cond
-      [(stx? x) (stx-e x)]
-      [else x]))
-
-  (define label? string?)
-
-  (define (eqmarks? m1* m2*)
-    (cond
-      [(null? m1*) (null? m2*)]
-      [(memq (car m1*) m2*) (eqmarks? (cdr m1*) (remq (car m1*) m2*))]
-      [else #f]))
-
-  (define (rib-lookup sym m* sym* m** lab*)
-    (and (pair? sym*)
-        (if (and (eq? sym (car sym*))
-                 (eqmarks? m* (car m**)))
-            (car lab*)
-            (rib-lookup sym m* (cdr sym*) (cdr m**) (cdr lab*)))))
-
-  (define (ribcage-lookup sym m* rc)
-    (cond
-      [(pair? rc)
-       (let ([r (car rc)])
-         (cond
-           [(eq? r 'shift) 
-            (ribcage-lookup sym (cdr m*) (cdr rc))]
-           [else
-            (or (rib-lookup sym m* (rib-sym* r) (rib-marks* r) (rib-lab* r))
-                (ribcage-lookup sym m* (cdr rc)))]))]
-      [(top? rc) #f]
-      [else (error "BUG1")]))
-  
-  (define (resolve x)
-    (unless (id? x) (error "BUG2"))
-    (let ([sym (stx-e x)]
-          [m* (stx-marks x)]
-          [rc (stx-ribcage x)])
-      (or (ribcage-lookup sym m* rc)    ; bound            -> label
-          (getprop sym *syncase-macro*) ; top-level-macros -> pair
-          sym                           ; global           -> symbol
-          )))
-
-  (define (remove-last ls)
-    (let ([d (cdr ls)])
-      (cond
-        [(null? d) '()]
-        [else (cons (car ls) (remove-last d))])))
-
-  (define (unshift rc)
-    (cond
-      [(pair? rc)
-       (if (eq? (car rc) 'shift)
-           (cdr rc)
-           (cons (car rc) (unshift (cdr rc))))]
-      [else (error "BUG3: missing shift")]))
-
-  (define (push-wrap m r x)
-    (cond
-      [(stx? x)
-       (let ([xm (stx-marks x)])
-         (cond
-           [(and (pair? xm) (eq? (car xm) #f))
-            (make-stx (stx-e x)
-                      (append (remove-last m) (cdr xm))
-                      (unshift (append r (stx-ribcage x))))]
-           [else
-            (make-stx (stx-e x)
-                      (append m xm)
-                      (append r (stx-ribcage x)))]))]
-      [else (make-stx x m r)]))
-
-  (define (push-subst sym* marks* lab* x)
-    (cond
-      [(stx? x)
-       (make-stx (stx-e x)
-                 (stx-marks x)
-                 (cons (make-rib sym* marks* lab*) (stx-ribcage x)))]
-      [else
-       (make-stx x 
-                 '()
-                 (cons (make-rib sym* marks* lab*) '()))]))
-
-  (define (push-antimark x)
-    (cond
-      [(stx? x)
-       (make-stx (stx-e x)
-                 (cons #f (stx-marks x))
-                 (stx-ribcage x))]
-      [else (make-stx x (cons #f '()) '())]))
-
-  (define (push-mark m x)
-    (cond
-      [(stx? x)
-       (let ([m* (stx-marks x)])
-         (cond
-           [(and (pair? m*) (eq? (car m*) #f))
-            (make-stx (stx-e x) (cdr m*) (stx-ribcage x))]
-           [else
-            (make-stx (stx-e x) (cons m m*) (cons 'shift (stx-ribcage x)))]))]
-      [else
-       (make-stx x (list m) '(shift))]))
-
-  (define (push-rib rib x)
-    (cond
-      [(stx? x) 
-       (make-stx (stx-e x) (stx-marks x) (cons rib (stx-ribcage x)))]
-      [else (make-stx x '() (list rib))]))
-
-  (define (expose-stx x)
-    (let ([e (stx-e x)])
-      (cond
-        [(pair? e)
-         (let ([m (stx-marks x)]
-               [r (stx-ribcage x)])
-           (cons
-             (push-wrap m r (car e))
-             (push-wrap m r (cdr e))))]
-        [(vector? e)
-         (let ([m (stx-marks x)]
-               [r (stx-ribcage x)])
-           (list->vector
-             (map (lambda (x) (push-wrap m r x)) 
-                  (vector->list e))))]
-        [(null? e) e]
-        [else x])))
-
-  (define (expose x)
-    (cond
-      [(stx? x) (expose-stx x)]
-      [else x]))
-
-  (define (expose-ls ox)
-    (let loop ([x (expose ox)])
-      (cond
-        [(pair? x) (cons (car x) (loop (expose (cdr x))))]
-        [(null? x) '()]
-        [else (error 'expose-ls "BUG: not a list: ~s" x)])))
-
-  (define (expose* x)
-    (cond
-      [(id? x) x]
-      [(stx? x) (expose* (expose x))]
-      [(pair? x) (cons (expose* (car x)) (expose* (cdr x)))]
-      [(vector? x) 
-       (list->vector (map expose* (vector->list x)))]
-      [else x]))
-
-  (define (lookup lab r)
-    (define (lookup1 lab lab* g*)
-      (cond
-        [(null? lab*) #f]
-        [(eq? lab (car lab*)) (car g*)]
-        [else (lookup1 lab (cdr lab*) (cdr g*))]))
-    (cond
-      [(null? r) #f]
-      [(eq? (car r) 'lexical-barrier)
-       (let ([v (lookup lab (cdr r))])
-         (cond
-           [(not (symbol? v)) v]
-           [else             #f]))]
-      [else
-       (or (lookup1 lab (caar r) (cdar r))
-           (lookup lab (cdr r)))]))
-
-  (define (genmark) (gensym "M"))
-  (define (newsym x) 
-    (gensym))
-    ;(gensym (symbol->string x)))
-
-  (define (apply-macro proc x r)
-    (expand-ctx (push-mark (genmark) (proc (push-antimark x))) r))
-      
-  (define (identifier-macro? x r)
-    (and (id? x)
-         (let ([a (resolve x)])
-           (or (and (label? a)
-                    (let ([a (lookup a r)])
-                      (and (procedure? a) a)))
-               (and (pair? a)
-                    (eq? (car a) '*user-macro*)
-                    (cdr a))))))
-
-  (define (macro-call? x r)
-    (if (id? x)
-        (identifier-macro? x r)
-        (let ([x (expose x)])
-          (and (pair? x)
-               (identifier-macro? (car x) r)))))
-
-  (define (core? x)
-    (and (pair? x) (eq? (car x) '*core-macro*)))
-
-  (define (apply-core-form a d ctx r)
-    (unless (core? a) (syntax-error ctx))
-    ((cdr a) a d ctx r))
-
-  (define (E* d r ctx)
-    (let ([d (expose-ls d)])
-      (map (lambda (x) (E x r)) d)))
-
-  (define (extend-core name proc)
-    (putprop name *syncase-macro* (cons '*core-macro* proc)))
-
-  (define (extend-user-macro name proc)
-    (putprop name *syncase-macro* (cons '*user-macro* proc)))
-
-  (define (E ctx r)
-    (let ([x (expose ctx)])
-      (cond
-        [(macro-call? x r) =>
-         (lambda (proc)
-           (apply-macro proc ctx r))]
-        [(pair? x)
-         (let ([a (car x)] [d (cdr x)])
-           (cond
-             [(id? a)
-              (let ([a (resolve a)])
-                (cond
-                  [(label? a)
-                   (cond
-                     [(lookup a r) =>
-                      (lambda (g)
-                        (cond
-                          [(symbol? g)
-                           (build-app (build-lexical-ref g) 
-                                      (E* d r ctx))]
-                          [(and (pair? g) (eq? (car g) 'pat))
-                           (syntax-error ctx)]
-                          [else (error 'expand "BUG4")]))]
-                     [else (syntax-error ctx)])]
-                  [(core? a)
-                   (apply-core-form a d ctx r)]
-                  [(symbol? a)
-                   (build-app (build-global-ref a) 
-                              (E* d r ctx))]
-                  [else (syntax-error ctx)]))]
-             [else
-              (build-app 
-                (E a r)
-                (E* d r ctx))]))]
-        [(id? x)
-         (let ([a (resolve x)])
-           (cond
-             [(label? a)
-              (cond
-                [(lookup a r) =>
-                 (lambda (g)
-                   (cond
-                     [(symbol? g) (build-lexical-ref g)]
-                     [(and (pair? g) (eq? (car g) 'pat))
-                      (syntax-error ctx)]
-                     [else (error 'expand "BUG5")]))]
-                [else (syntax-error ctx)])]
-             [(core? a) (syntax-error ctx)]
-             [(symbol? a)
-              (build-global-ref a)]
-             [else (syntax-error ctx)]))]
-        [else (build-data (strip x))])))
-
-  (define (core-expand x)
-    (E (make-stx x '() *top-ribcage*) '()))
-
-  (define (process-fml* bind* ctx)
-    (define (assert-no-dups s m* s* m**)
-      (unless (null? s*)
-        (when (and (eq? s (car s*))
-                   (eqmarks? m* (car m**)))
-          (syntax-error ctx))
-        (assert-no-dups s m* (cdr s*) (cdr m*))))
-    (let loop ([bind* (expose bind*)])
-      (cond
-        [(null? bind*) (values '() '() '() '() '())]
-        [(pair? bind*)
-         (let ([b (car bind*)])
-           (unless (id? b) (syntax-error ctx))
-           (let-values ([(fml* s* m** g* lab*) 
-                         (loop (expose (cdr bind*)))])
-             (let ([s (stx-e b)] [m* (stx-marks b)])
-               (assert-no-dups s m* s* m**)
-               (let ([lab (string #\i)] [g (newsym s)])
-                 (values (cons g fml*)
-                         (cons s s*)
-                         (cons m* m**)
-                         (cons g g*)
-                         (cons lab lab*))))))]
-        [else (syntax-error ctx)])))
-
-  (define (top-level-macro? x r sym)
-    (let ([x (expose x)])
-      (and (pair? x)
-           (id? (car x))
-           (let ([loc (resolve (car x))])
-             (and (or (and (pair? loc) 
-                           (eq? (car loc) '*core-macro*))
-                      (symbol? loc))
-                  (eq? (stx->datum (car x)) sym))))))
-
-  (define (define? x r)
-    (top-level-macro? x r 'define))
-
-  (define (begin? x r)
-    (top-level-macro? x r 'begin))
-
-  (define (begin-e* x ctx)
-    (let ([x (expose x)])
-      (let loop ([x (expose (cdr x))])
-        (cond
-          [(null? x) '()]
-          [(pair? x) (cons (car x) (loop (expose (cdr x))))]
-          [else (syntax-error ctx)]))))
-
-  (define (expand-body* body* ctx r)
-    (let ([rib (make-rib '() '() '())])
-      (let loop ([body* (expose (push-rib rib body*))]
-                 [r r]
-                 [lab* '()] [sym* '()] [marks* '()] [vrhs* '()])
-        (cond
-          [(null? body*) (syntax-error ctx)]
-          [(pair? body*)
-           (let ([a (car body*)] [d (cdr body*)])
-             (cond
-               [(macro-call? a r) =>
-                (lambda (proc)
-                  (loop (cons (push-mark (genmark) (proc (push-antimark a))) d)
-                        r lab* sym* marks* vrhs*))]
-               [(define? a r)
-                (let-values ([(lhs rhs) (extract-define a ctx)])
-                  (loop (expose d) 
-                        r
-                        (cons (string #\p) lab*)
-                        (cons (stx-e lhs) sym*)
-                        (cons (stx-marks lhs) marks*)
-                        (cons rhs vrhs*)))]
-               [(begin? a r)
-                (loop (expose (append (begin-e* a ctx) d))
-                      r lab* sym* marks* vrhs*)]
-               [else
-                ;;; done
-                (cond
-                  [(null? sym*) 
-                   (let ([body* (E* body* r ctx)])
-                     (build-begin body*))]
-                  [else
-                   (let ([g* (map newsym sym*)])
-                     (let* ([r (cons (cons lab* g*) r)]
-                            [rhs* 
-                             (E* (push-subst sym* marks* lab* vrhs*)
-                                          r ctx)]
-                            [body* 
-                             (E* (push-subst sym* marks* lab* body*)
-                                          r ctx)])
-                       (build-letrec g* rhs* (build-begin body*))))])]))]
-          [else (syntax-error ctx)]))))
-
-  (define (extract-bindings bind* ctx)
-    (let ([bind* (expose bind*)])
-      (cond
-        [(null? bind*) (values '() '())]
-        [(not (pair? bind*)) (syntax-error ctx)]
-        [else
-         (let ([a (car bind*)] [d (cdr bind*)])
-           (let ([a (expose-ls a)])
-             (cond
-               [(fx= (length a) 2)
-                (let-values ([(lhs* rhs*) 
-                              (extract-bindings d ctx)])
-                  (values (cons (car a) lhs*)
-                          (cons (cadr a) rhs*)))]
-               [else (syntax-error ctx)])))])))
-
-  (define (core-stx x)
-    (make-stx x '() *top-ribcage*))
-
-  (extend-core 'quote
-    (lambda (a d ctx r)
-      (let ([d (expose-ls d)])
-        (cond
-          [(and (list? d) (fx= (length d) 1))
-           (build-data (strip (car d)))]
-          [else (syntax-error ctx)]))))
-
-  (extend-core 'lambda
-    (lambda (a d ctx r)
-      (let ([d (expose d)])
-        (cond
-          [(pair? d)
-           (let ([fml* (car d)] [body* (cdr d)])
-             (let-values ([(fml* s* m** g* lab*)
-                           (process-fml* fml* ctx)])
-               (let ([body* (push-subst s* m** lab* body*)])
-                 (let ([r (cons (cons lab* g*) r)])
-                   (build-lambda fml* 
-                     (expand-body* body* ctx r))))))]
-          [else (syntax-error ctx)]))))
-
-  (extend-core 'if
-    (lambda (a d ctx r)
-      (let ([d (expose d)])
-        (unless (pair? d) (syntax-error ctx))
-        (let ([test (car d)] [d (expose (cdr d))])
-          (unless (pair? d) (syntax-error ctx))
-          (let ([conseq (car d)] [d (expose (cdr d))])
-            (let ([altern
-                   (cond
-                     [(null? d) (build-void)]
-                     [(pair? d)
-                      (let ([altern (car d)] [d (expose (cdr d))])
-                        (cond
-                          [(null? d) (E altern r)]
-                          [else (syntax-error ctx)]))]
-                     [else (syntax-error ctx)])])
-              (build-if (E test r) (E conseq r) altern)))))))
-
-  (extend-core 'begin
-    (lambda (a d ctx r)
-      (let ([d (expose-ls d)])
-        (when (null? d) (syntax-error ctx))
-        (build-begin (E* d r ctx)))))
-
-
-  (extend-core 'define 
-    (lambda (a d ctx r) (syntax-error ctx)))
-
-  (extend-core 'foreign-call
-    (lambda (a d ctx r)
-      (let ([d (expose-ls d)])
-        (unless (fx>= (length d) 1) (syntax-error ctx))
-        (build-foreign-call
-          (E (car d) r)
-          (E* (cdr d) r ctx)))))
-
-  (extend-core 'let
-    (lambda (a d ctx r)
-      (let ([d (expose d)])
-        (unless (pair? d) (syntax-error ctx))
-        (let ([bind* (car d)] [body* (cdr d)])
-          (let-values ([(lhs* rhs*) 
-                        (extract-bindings bind* ctx)])
-            (let ([lambda^ (core-stx 'lambda)])
-              (E `((,lambda^ ,lhs* . ,body*) . ,rhs*) r)))))))
-
-  (extend-core 'let*
-    (lambda (a d ctx r)
-      (let ([d (expose d)])
-        (unless (pair? d) (syntax-error ctx))
-        (let ([bind* (car d)] [body* (cdr d)])
-          (let-values ([(lhs* rhs*)
-                        (extract-bindings bind* ctx)])
-            (let ([lambda^ (core-stx 'lambda)])
-              (E (let f ([lhs* lhs*] [rhs* rhs*])
-                   (cond
-                     [(null? lhs*) 
-                      `((,lambda^ () . ,body*))]
-                     [else
-                      `((,lambda^ (,(car lhs*)) 
-                          ,(f (cdr lhs*) (cdr rhs*)))
-                        ,(car rhs*))]))
-                 r)))))))
-
-  (set! expand core-expand)
-)
diff --git a/src/libtokenizer.fasl b/src/libtokenizer.fasl
index 3ef1482..6060fa1 100644
Binary files a/src/libtokenizer.fasl and b/src/libtokenizer.fasl differ
diff --git a/src/libtoplevel-6.9.ss b/src/libtoplevel-6.9.ss
new file mode 100644
index 0000000..5be0b17
--- /dev/null
+++ b/src/libtoplevel-6.9.ss
@@ -0,0 +1,61 @@
+
+(for-each
+  (lambda (x)
+    ($set-symbol-value! x (primitive-ref x)))
+  (public-primitives))
+
+(let ()
+  (define add-prim 
+    (lambda (x)
+      (let ([g (gensym (symbol->string x))])
+        (putprop x '|#system| g)
+        (putprop g '*sc-expander* (cons 'core-primitive x)))))
+  (for-each add-prim (public-primitives))
+  (for-each add-prim (system-primitives)))
+
+(for-each
+  (lambda (x)
+    (cond
+      [(getprop x '*sc-expander*) =>
+       (lambda (p)
+         (let ([g (gensym (symbol->string x))])
+           (putprop x '|#system| g)
+           (putprop g '*sc-expander* p)))]
+      [(getprop x '|#system|) =>
+       (lambda (g)
+         (let ([p (getprop g '*sc-expander*)])
+           (putprop x '*sc-expander* p)))]
+      [else (error #f "~s is not a macro" x)]))
+  (macros))
+
+(let ([gsys (gensym "#system")] [gsch (gensym "*scheme*")])
+  (define (make-stx x)
+    (vector 'syntax-object x 
+            (list '(top) 
+                  (vector 'ribcage 
+                          (vector x)
+                          (vector '(top))
+                          (vector (getprop x '|#system|))))))
+  (define (make-module stx* name)
+    `($module . #(interface (top) ,(list->vector stx*) ,name)))
+  (putprop '|#system| '|#system| gsys)
+  (putprop 'scheme  '|#system| gsch)
+  (putprop 'scheme '*scheme* gsch)
+  (let* ([schls (append '(scheme) (public-primitives) (macros))]
+         [sysls (append '(|#system|) (system-primitives) schls)])
+    (let ([sysmod (make-module (map make-stx sysls) '|#system|)]
+          [schmod (make-module (map make-stx schls) '*scheme*)])
+      (for-each 
+        (lambda (x)
+          (putprop x '*scheme* (getprop x '|#system|)))
+        schls)
+      (putprop gsch '*sc-expander* schmod)
+      (putprop gsys '*sc-expander* sysmod)
+      (putprop '|#system| '*sc-expander* sysmod)
+      (putprop 'scheme '*sc-expander* schmod))))
+
+(begin
+  (printf "Petite Ikarus Scheme (Build ~a)\n" (compile-time-date-string))
+  (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n")
+  (current-eval compile)
+  (new-cafe))
diff --git a/src/libtoplevel.fasl b/src/libtoplevel.fasl
index d25a608..c93904f 100644
Binary files a/src/libtoplevel.fasl and b/src/libtoplevel.fasl differ
diff --git a/src/libtrace-6.9.ss b/src/libtrace-6.9.ss
new file mode 100644
index 0000000..1b01788
--- /dev/null
+++ b/src/libtrace-6.9.ss
@@ -0,0 +1,89 @@
+
+(let ()
+  (define k* '())
+  
+  (define display-prefix
+    (lambda (ls t)
+      (unless (null? ls)
+        (display (if t "|" " "))
+        (display-prefix (cdr ls) (not t)))))
+  
+  (define display-trace
+    (lambda (k* v)
+      (display-prefix k* #t)
+      (write v)
+      (newline)))
+
+  (define make-traced-procedure
+    (lambda (name proc)
+      (lambda args
+        (call/cf
+          (lambda (f)
+            (cond
+              [(memq f k*) => 
+               (lambda (ls)
+                 (display-trace ls (cons name args))
+                 (apply proc args))]
+              [else
+               (display-trace (cons 1 k*) (cons name args))
+               (dynamic-wind
+                 (lambda () (set! k* (cons f k*)))
+                 (lambda () 
+                   (let ([v 
+                          (call/cf
+                            (lambda (nf)
+                              (set! f nf)
+                              (set-car! k* nf)
+                              (apply proc args)))])
+                     (display-trace k* v)
+                     v))
+                 (lambda () (set! k* (cdr k*))))]))))))
+      
+  (define traced-symbols '())
+
+  (define trace-symbol!
+    (lambda (s)
+      (cond
+        [(assq s traced-symbols) =>
+         (lambda (pr)
+           (let ([a (cdr pr)] [v (top-level-value s)])
+             (unless (eq? (cdr a) v)
+               (unless (procedure? v)
+                 (error 'trace
+                        "the top-level value of ~s is ~s (not a procedure)"
+                     s v))
+               (let ([p (make-traced-procedure s v)])
+                 (set-car! a v)
+                 (set-cdr! a p)
+                 (set-top-level-value! s p)))))]
+        [else
+         (unless (top-level-bound? s)
+           (error 'trace "~s is unbound" s))
+         (let ([v (top-level-value s)])
+           (unless (procedure? v)
+             (error 'trace "the top-level value of ~s is ~s (not a procedure)"
+                    s v))
+           (let ([p (make-traced-procedure s v)])
+             (set! traced-symbols 
+               (cons (cons s (cons v p)) traced-symbols))
+             (set-top-level-value! s p)))])))
+  
+  (define untrace-symbol!
+    (lambda (s)
+      (define loop
+        (lambda (ls)
+          (cond
+            [(null? ls) '()]
+            [(eq? s (caar ls))
+             (let ([a (cdar ls)])
+               (when (eq? (cdr a) (top-level-value s))
+                 (set-top-level-value! s (car a)))
+               (cdr ls))]
+            [else (cons (car ls) (loop (cdr ls)))])))
+      (set! traced-symbols (loop traced-symbols))))
+
+  (primitive-set! 'make-traced-procedure make-traced-procedure)
+  (primitive-set! 'trace-symbol! trace-symbol!)
+  (primitive-set! 'untrace-symbol! untrace-symbol!))
+
+
diff --git a/src/libwriter-6.2.ss b/src/libwriter-6.2.ss
index 2f114f8..1dc06ca 100644
--- a/src/libwriter-6.2.ss
+++ b/src/libwriter-6.2.ss
@@ -308,13 +308,15 @@
         (error 'fprintf "~s is not an output port" port))
       (unless (string? fmt)
         (error 'fprintf "~s is not a string" fmt))
-      (formatter 'fprintf port fmt args)))
+      (formatter 'fprintf port fmt args)
+      (flush-output-port port)))
 
   (define printf
     (lambda (fmt . args)
       (unless (string? fmt)
         (error 'printf "~s is not a string" fmt))
-      (formatter 'printf (current-output-port) fmt args)))
+      (formatter 'printf (current-output-port) fmt args)
+      (flush-output-port (current-output-port))))
 
   (define format
     (lambda (fmt . args)
@@ -369,5 +371,6 @@
             (error 'current-error-handler "~s is not a procedure" x)))))
   (primitive-set! 'error
     (lambda args
-      (apply (current-error-handler) args)))) 
+      (apply (current-error-handler) args)))
+  ) 
 
diff --git a/src/libwriter.fasl b/src/libwriter.fasl
index 05fb9ce..c6f70d2 100644
Binary files a/src/libwriter.fasl and b/src/libwriter.fasl differ
diff --git a/src/message-case.ss b/src/message-case.ss
new file mode 100644
index 0000000..4831666
--- /dev/null
+++ b/src/message-case.ss
@@ -0,0 +1,24 @@
+
+
+(define-syntax message-case
+  (syntax-rules  (else)
+    [(_ msg args 
+        [(msg-name msg-arg* ...) b b* ...] ... 
+        [else else1 else2 ...])
+     (let ([tmsg msg] [targs args])
+       (define-syntax match-and-bind
+         (syntax-rules ()
+           [(__ y () body)
+            (if (null? y) 
+                body
+                (error 'message-case "unmatched ~s" (cons tmsg targs)))]
+           [(__ y (a a* (... ...)) body)
+            (if (pair? y)
+                (let ([a (car y)] [d (cdr y)])
+                  (match-and-bind d (a* (... ...)) body))
+                (error 'message-case "unmatched ~s" (cons tmsg targs)))]))
+       (case tmsg
+         [(msg-name) 
+          (match-and-bind targs (msg-arg* ...) (begin b b* ...))] ...
+         [else else1 else2 ...]))]))
+
diff --git a/src/petite-ikarus.fasl b/src/petite-ikarus.fasl
deleted file mode 100644
index 35ae3ac..0000000
Binary files a/src/petite-ikarus.fasl and /dev/null differ
diff --git a/src/psyntax-7.1-6.5.ss b/src/psyntax-7.1-6.5.ss
new file mode 100644
index 0000000..d45f439
--- /dev/null
+++ b/src/psyntax-7.1-6.5.ss
@@ -0,0 +1,4613 @@
+;;; Portable implementation of syntax-case
+;;; Extracted from Chez Scheme Version 7.1 (Aug 01, 2006)
+;;; Authors: R. Kent Dybvig, Oscar Waddell, Bob Hieb, Carl Bruggeman
+
+;;; Copyright (c) 1992-2002 Cadence Research Systems
+;;; Permission to copy this software, in whole or in part, to use this
+;;; software for any lawful purpose, and to redistribute this software
+;;; is granted subject to the restriction that all copies made of this
+;;; software must include this copyright notice in full.  This software
+;;; is provided AS IS, with NO WARRANTY, EITHER EXPRESS OR IMPLIED,
+;;; INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY
+;;; OR FITNESS FOR ANY PARTICULAR PURPOSE.  IN NO EVENT SHALL THE
+;;; AUTHORS BE LIABLE FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY
+;;; NATURE WHATSOEVER.
+
+;;; Before attempting to port this code to a new implementation of
+;;; Scheme, please read the notes below carefully.
+
+;;; This file defines the syntax-case expander, sc-expand, and a set
+;;; of associated syntactic forms and procedures.  Of these, the
+;;; following are documented in The Scheme Programming Language,
+;;; Third Edition (R. Kent Dybvig, MIT Press, 2003), which can be
+;;; found online at http://www.scheme.com/tspl3/.  Most are also documented
+;;; in the R4RS and draft R5RS.
+;;;
+;;;   bound-identifier=?
+;;;   datum->syntax-object
+;;;   define-syntax
+;;;   fluid-let-syntax
+;;;   free-identifier=?
+;;;   generate-temporaries
+;;;   identifier?
+;;;   identifier-syntax
+;;;   let-syntax
+;;;   letrec-syntax
+;;;   syntax
+;;;   syntax-case
+;;;   syntax-object->datum
+;;;   syntax-rules
+;;;   with-syntax
+;;;
+;;; All standard Scheme syntactic forms are supported by the expander
+;;; or syntactic abstractions defined in this file.  Only the R4RS
+;;; delay is omitted, since its expansion is implementation-dependent.
+
+;;; Also defined are three forms that support modules: module, import,
+;;; and import-only.  These are documented in the Chez Scheme User's
+;;; Guide (R. Kent Dybvig, Cadence Research Systems, 1998), which can
+;;; also be found online at http://www.scheme.com/csug/.  They are
+;;; described briefly here as well.
+    
+;;; All are definitions and may appear where and only where other
+;;; definitions may appear.  modules may be named:
+;;;
+;;;   (module id (ex ...) defn ... init ...)
+;;;
+;;; or anonymous:
+;;;
+;;;   (module (ex ...) defn ... init ...)
+;;;
+;;; The latter form is semantically equivalent to:
+;;;
+;;;   (module T (ex ...) defn ... init ...)
+;;;   (import T)
+;;;
+;;; where T is a fresh identifier.
+;;;
+;;; In either form, each of the exports in (ex ...) is either an
+;;; identifier or of the form (id ex ...).  In the former case, the
+;;; single identifier ex is exported.  In the latter, the identifier
+;;; id is exported and the exports ex ... are "implicitly" exported.
+;;; This listing of implicit exports is useful only when id is a
+;;; keyword bound to a transformer that expands into references to
+;;; the listed implicit exports.  In the present implementation,
+;;; listing of implicit exports is necessary only for top-level
+;;; modules and allows the implementation to avoid placing all
+;;; identifiers into the top-level environment where subsequent passes
+;;; of the compiler will be unable to deal effectively with them.
+;;;
+;;; Named modules may be referenced in import statements, which
+;;; always take one of the forms:
+;;;
+;;;   (import id)
+;;;   (import-only id)
+;;;
+;;; id must name a module.  Each exported identifier becomes visible
+;;; within the scope of the import form.  In the case of import-only,
+;;; all other identifiers become invisible in the scope of the
+;;; import-only form, except for those established by definitions
+;;; that appear textually after the import-only form.
+
+;;; import and import-only also support a variety of identifier
+;;; selection and renaming forms: only, except, add-prefix,
+;;; drop-prefix, rename, and alias.
+;;;
+;;;   (import (only m x y))
+;;; 
+;;; imports x and y (and nothing else) from m.
+;;;
+;;;   (import (except m x y))
+;;; 
+;;; imports all of m's imports except for x and y.
+;;;
+;;;   (import (add-prefix (only m x y) m:))
+;;; 
+;;; imports x and y as m:x and m:y.
+;;;
+;;;   (import (drop-prefix m foo:))
+;;; 
+;;; imports all of m's imports, dropping the common foo: prefix
+;;; (which must appear on all of m's exports).
+;;; 
+;;;   (import (rename (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, renaming c
+;;; m-c and d m-d.
+;;; 
+;;;   (import (alias (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, with additional
+;;; aliases m-c for c and m-d for d.
+;;; 
+;;; multiple imports may be specified with one import form:
+;;; 
+;;;   (import (except m1 x) (only m2 x))
+;;; 
+;;; imports all of m1's exports except for x plus x from m2.
+
+;;; Another form, meta, may be used as a prefix for any definition and
+;;; causes any resulting variable bindings to be created at expansion
+;;; time.  Meta variables (variables defined using meta) are available
+;;; only at expansion time.  Meta definitions are often used to create
+;;; data and helpers that can be shared by multiple macros, for example:
+
+;;; (module (alpha beta)
+;;;   (meta define key-error
+;;;     (lambda (key)
+;;;       (syntax-error key "invalid key")))
+;;;   (meta define parse-keys
+;;;     (lambda (keys)
+;;;       (let f ((keys keys) (c #'white) (s 10))
+;;;         (syntax-case keys (color size)
+;;;           (() (list c s))
+;;;           (((color c) . keys) (f #'keys #'c s))
+;;;           (((size s) . keys) (f #'keys c #'s))
+;;;           ((k . keys) (key-error #'k))))))
+;;;   (define-syntax alpha
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---)))))
+;;;   (define-syntax beta
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---))))))
+
+;;; As with define-syntax rhs expressions, meta expressions can evaluate
+;;; references only to identifiers whose values are (already) available
+;;; in the compile-time environment, e.g., macros and meta variables.
+;;; They can, however, like define-syntax rhs expressions, build syntax
+;;; objects containing occurrences of any identifiers in their scope.
+
+;;; meta definitions propagate through macro expansion, so one can write,
+;;; for example:
+;;; 
+;;;   (module (a)
+;;;     (meta define-structure (foo x))
+;;;     (define-syntax a
+;;;       (let ((q (make-foo (syntax 'q))))
+;;;         (lambda (x)
+;;;           (foo-x q)))))
+;;;   a -> q
+;;; 
+;;; where define-record is a macro that expands into a set of defines.
+;;; 
+;;; It is also sometimes convenient to write
+;;; 
+;;;   (meta begin defn ...)
+;;; 
+;;; or
+;;; 
+;;;   (meta module {exports} defn ...)
+;;; 
+;;; to create groups of meta bindings.
+
+;;; Another form, alias, is used to create aliases from one identifier
+;;; to another.  This is used primarily to support the extended import
+;;; syntaxes (add-prefix, drop-prefix, rename, and alias).
+
+;;; (let ((x 3)) (alias y x) y) -> 3
+
+;;; The remaining exports are listed below.  sc-expand, eval-when, and
+;;; syntax-error are described in the Chez Scheme User's Guide.
+;;;
+;;;   (sc-expand datum)
+;;;      if datum represents a valid expression, sc-expand returns an
+;;;      expanded version of datum in a core language that includes no
+;;;      syntactic abstractions.  The core language includes begin,
+;;;      define, if, lambda, letrec, quote, and set!.
+;;;   (eval-when situations expr ...)
+;;;      conditionally evaluates expr ... at compile-time or run-time
+;;;      depending upon situations
+;;;   (syntax-error object message)
+;;;      used to report errors found during expansion
+;;;   ($syntax-dispatch e p)
+;;;      used by expanded code to handle syntax-case matching
+;;;   ($sc-put-cte symbol val top-token)
+;;;      used to establish top-level compile-time (expand-time) bindings.
+
+;;; The following nonstandard procedures must be provided by the
+;;; implementation for this code to run.
+;;;
+;;; (void)
+;;; returns the implementation's cannonical "unspecified value".  The
+;;; following usually works:
+;;;
+;;; (define void (lambda () (if #f #f))).
+;;;
+;;; (andmap proc list1 list2 ...)
+;;; returns true if proc returns true when applied to each element of list1
+;;; along with the corresponding elements of list2 ....  The following
+;;; definition works but does no error checking:
+;;;
+;;; (define andmap
+;;;   (lambda (f first . rest)
+;;;     (or (null? first)
+;;;         (if (null? rest)
+;;;             (let andmap ((first first))
+;;;               (let ((x (car first)) (first (cdr first)))
+;;;                 (if (null? first)
+;;;                     (f x)
+;;;                     (and (f x) (andmap first)))))
+;;;             (let andmap ((first first) (rest rest))
+;;;               (let ((x (car first))
+;;;                     (xr (map car rest))
+;;;                     (first (cdr first))
+;;;                     (rest (map cdr rest)))
+;;;                 (if (null? first)
+;;;                     (apply f (cons x xr))
+;;;                     (and (apply f (cons x xr)) (andmap first rest)))))))))
+;;;
+;;; (ormap proc list1)
+;;; returns the first non-false return result of proc applied to
+;;; the elements of list1 or false if none.  The following definition
+;;; works but does no error checking:
+;;;
+;;; (define ormap
+;;;   (lambda (proc list1)
+;;;     (and (not (null? list1))
+;;;          (or (proc (car list1)) (ormap proc (cdr list1))))))
+;;;
+;;; The following nonstandard procedures must also be provided by the
+;;; implementation for this code to run using the standard portable
+;;; hooks and output constructors.  They are not used by expanded code,
+;;; and so need be present only at expansion time.
+;;;
+;;; (eval x)
+;;; where x is always in the form ("noexpand" expr).
+;;; returns the value of expr.  the "noexpand" flag is used to tell the
+;;; evaluator/expander that no expansion is necessary, since expr has
+;;; already been fully expanded to core forms.
+;;;
+;;; eval will not be invoked during the loading of psyntax.pp.  After
+;;; psyntax.pp has been loaded, the expansion of any macro definition,
+;;; whether local or global, results in a call to eval.  If, however,
+;;; sc-expand has already been registered as the expander to be used
+;;; by eval, and eval accepts one argument, nothing special must be done
+;;; to support the "noexpand" flag, since it is handled by sc-expand.
+;;;
+;;; (error who format-string why what)
+;;; where who is either a symbol or #f, format-string is always "~a ~s",
+;;; why is always a string, and what may be any object.  error should
+;;; signal an error with a message something like
+;;;
+;;;    "error in <who>: <why> <what>"
+;;;
+;;; (gensym)
+;;; returns a unique symbol each time it's called.  In Chez Scheme, gensym
+;;; returns a symbol with a "globally" unique name so that gensyms that
+;;; end up in the object code of separately compiled files cannot conflict.
+;;; This is necessary only if you intend to support compiled files.
+;;;
+;;; (gensym? x)
+;;; returns #t if x is a gensym, otherwise false.
+;;;
+;;; (putprop symbol key value)
+;;; (getprop symbol key)
+;;; (remprop symbol key)
+;;; key is always a symbol; value may be any object.  putprop should
+;;; associate the given value with the given symbol and key in some way
+;;; that it can be retrieved later with getprop.  getprop should return
+;;; #f if no value is associated with the given symbol and key.  remprop
+;;; should remove the association between the given symbol and key.
+
+;;; When porting to a new Scheme implementation, you should define the
+;;; procedures listed above, load the expanded version of psyntax.ss
+;;; (psyntax.pp, which should be available whereever you found
+;;; psyntax.ss), and register sc-expand as the current expander (how
+;;; you do this depends upon your implementation of Scheme).  You may
+;;; change the hooks and constructors defined toward the beginning of
+;;; the code below, but to avoid bootstrapping problems, do so only
+;;; after you have a working version of the expander.
+
+;;; Chez Scheme allows the syntactic form (syntax <template>) to be
+;;; abbreviated to #'<template>, just as (quote <datum>) may be
+;;; abbreviated to '<datum>.  The #' syntax makes programs written
+;;; using syntax-case shorter and more readable and draws out the
+;;; intuitive connection between syntax and quote.  If you have access
+;;; to the source code of your Scheme system's reader, you might want
+;;; to implement this extension.
+
+;;; If you find that this code loads or runs slowly, consider
+;;; switching to faster hardware or a faster implementation of
+;;; Scheme.  In Chez Scheme on a 200Mhz Pentium Pro, expanding,
+;;; compiling (with full optimization), and loading this file takes
+;;; between one and two seconds.
+
+;;; In the expander implementation, we sometimes use syntactic abstractions
+;;; when procedural abstractions would suffice.  For example, we define
+;;; top-wrap and top-marked? as
+;;;   (define-syntax top-wrap (identifier-syntax '((top))))
+;;;   (define-syntax top-marked?
+;;;     (syntax-rules ()
+;;;       ((_ w) (memq 'top (wrap-marks w)))))
+;;; rather than
+;;;   (define top-wrap '((top)))
+;;;   (define top-marked?
+;;;     (lambda (w) (memq 'top (wrap-marks w))))
+;;; On ther other hand, we don't do this consistently; we define make-wrap,
+;;; wrap-marks, and wrap-subst simply as
+;;;   (define make-wrap cons)
+;;;   (define wrap-marks car)
+;;;   (define wrap-subst cdr)
+;;; In Chez Scheme, the syntactic and procedural forms of these
+;;; abstractions are equivalent, since the optimizer consistently
+;;; integrates constants and small procedures.  Some Scheme
+;;; implementations, however, may benefit from more consistent use
+;;; of one form or the other.
+
+
+;;; Implementation notes:
+
+;;; "begin" is treated as a splicing construct at top level and at
+;;; the beginning of bodies.  Any sequence of expressions that would
+;;; be allowed where the "begin" occurs is allowed.
+
+;;; "let-syntax" and "letrec-syntax" are also treated as splicing
+;;; constructs, in violation of the R5RS.  A consequence is that let-syntax
+;;; and letrec-syntax do not create local contours, as do let and letrec.
+;;; Although the functionality is greater as it is presently implemented,
+;;; we will probably change it to conform to the R5RS.  modules provide
+;;; similar functionality to nonsplicing letrec-syntax when the latter is
+;;; used as a definition.
+
+;;; Objects with no standard print syntax, including objects containing
+;;; cycles and syntax objects, are allowed in quoted data as long as they
+;;; are contained within a syntax form or produced by datum->syntax-object.
+;;; Such objects are never copied.
+
+;;; When the expander encounters a reference to an identifier that has
+;;; no global or lexical binding, it treats it as a global-variable
+;;; reference.  This allows one to write mutually recursive top-level
+;;; definitions, e.g.:
+;;;
+;;;   (define f (lambda (x) (g x)))
+;;;   (define g (lambda (x) (f x)))
+;;;
+;;; but may not always yield the intended when the variable in question
+;;; is later defined as a keyword.
+
+;;; Top-level variable definitions of syntax keywords are permitted.
+;;; In order to make this work, top-level define not only produces a
+;;; top-level definition in the core language, but also modifies the
+;;; compile-time environment (using $sc-put-cte) to record the fact
+;;; that the identifier is a variable.
+
+;;; Top-level definitions of macro-introduced identifiers are visible
+;;; only in code produced by the macro.  That is, a binding for a
+;;; hidden (generated) identifier is created instead, and subsequent
+;;; references within the macro output are renamed accordingly.  For
+;;; example:
+;;;
+;;; (define-syntax a
+;;;   (syntax-rules ()
+;;;     ((_ var exp)
+;;;      (begin
+;;;        (define secret exp)
+;;;        (define var
+;;;          (lambda ()
+;;;            (set! secret (+ secret 17))
+;;;            secret))))))
+;;; (a x 0)
+;;; (x) => 17
+;;; (x) => 34
+;;; secret => Error: variable secret is not bound
+;;;
+;;; The definition above would fail if the definition for secret
+;;; were placed after the definition for var, since the expander would
+;;; encounter the references to secret before the definition that
+;;; establishes the compile-time map from the identifier secret to
+;;; the generated identifier.
+
+;;; Identifiers and syntax objects are implemented as vectors for
+;;; portability.  As a result, it is possible to "forge" syntax
+;;; objects.
+
+;;; The input to sc-expand may contain "annotations" describing, e.g., the
+;;; source file and character position from where each object was read if
+;;; it was read from a file.  These annotations are handled properly by
+;;; sc-expand only if the annotation? hook (see hooks below) is implemented
+;;; properly and the operators annotation-expression and annotation-stripped
+;;; are supplied.  If annotations are supplied, the proper annotated
+;;; expression is passed to the various output constructors, allowing
+;;; implementations to accurately correlate source and expanded code.
+;;; Contact one of the authors for details if you wish to make use of
+;;; this feature.
+
+;;; Implementation of modules:
+;;;
+;;; The implementation of modules requires that implicit top-level exports
+;;; be listed with the exported macro at some level where both are visible,
+;;; e.g.,
+;;;
+;;;   (module M (alpha (beta b))
+;;;     (module ((alpha a) b)
+;;;       (define-syntax alpha (identifier-syntax a))
+;;;       (define a 'a)
+;;;       (define b 'b))
+;;;     (define-syntax beta (identifier-syntax b)))
+;;;
+;;; Listing of implicit imports is not needed for macros that do not make
+;;; it out to top level, including all macros that are local to a "body".
+;;; (They may be listed in this case, however.)  We need this information
+;;; for top-level modules since a top-level module expands into a letrec
+;;; for non-top-level variables and top-level definitions (assignments) for
+;;; top-level variables.  Because of the general nature of macro
+;;; transformers, we cannot determine the set of implicit exports from the
+;;; transformer code, so without the user's help, we'd have to put all
+;;; variables at top level.
+;;;
+;;; Each such top-level identifier is given a generated name (gensym).
+;;; When a top-level module is imported at top level, a compile-time
+;;; alias is established from the top-level name to the generated name.
+;;; The expander follows these aliases transparently.  When any module is
+;;; imported anywhere other than at top level, the id-var-name of the
+;;; import identifier is set to the id-var-name of the export identifier.
+;;; Since we can't determine the actual labels for identifiers defined in
+;;; top-level modules until we determine which are placed in the letrec
+;;; and which make it to top level, we give each an "indirect" label---a
+;;; pair whose car will eventually contain the actual label.  Import does
+;;; not follow the indirect, but id-var-name does.
+;;;
+;;; All identifiers defined within a local module are folded into the
+;;; letrec created for the enclosing body.  Visibility is controlled in
+;;; this case and for nested top-level modules by introducing a new wrap
+;;; for each module.
+
+
+;;; Bootstrapping:
+
+;;; When changing syntax-object representations, it is necessary to support
+;;; both old and new syntax-object representations in id-var-name.  It
+;;; should be sufficient to redefine syntax-object-expression to work for
+;;; both old and new representations and syntax-object-wrap to return the
+;;; empty-wrap for old representations.
+
+
+;;; The following set of definitions establishes bindings for the
+;;; top-level variables assigned values in the let expression below.
+;;; Uncomment them here and copy them to the front of psyntax.pp if
+;;; required by your system.
+
+; (define $sc-put-cte #f)
+; (define sc-expand #f)
+; (define $make-environment #f)
+; (define environment? #f)
+; (define interaction-environment #f)
+; (define identifier? #f)
+; (define syntax->list #f)
+; (define syntax-object->datum #f)
+; (define datum->syntax-object #f)
+; (define generate-temporaries #f)
+; (define free-identifier=? #f)
+; (define bound-identifier=? #f)
+; (define literal-identifier=? #f)
+; (define syntax-error #f)
+; (define $syntax-dispatch #f)
+
+
+(let ()
+
+(define-syntax when
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (if test (begin e1 e2 ...)))))
+(define-syntax unless
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (when (not test) (begin e1 e2 ...)))))
+(define-syntax define-structure
+  (lambda (x)
+    (define construct-name
+      (lambda (template-identifier . args)
+        (datum->syntax-object
+          template-identifier
+          (string->symbol
+            (apply string-append
+                   (map (lambda (x)
+                          (if (string? x)
+                              x
+                              (symbol->string (syntax-object->datum x))))
+                        args))))))
+    (syntax-case x ()
+      ((_ (name id1 ...))
+       (andmap identifier? (syntax (name id1 ...)))
+       (with-syntax
+         ((constructor (construct-name (syntax name) "make-" (syntax name)))
+          (predicate (construct-name (syntax name) (syntax name) "?"))
+          ((access ...)
+           (map (lambda (x) (construct-name x (syntax name) "-" x))
+                (syntax (id1 ...))))
+          ((assign ...)
+           (map (lambda (x)
+                  (construct-name x "set-" (syntax name) "-" x "!"))
+                (syntax (id1 ...))))
+          (structure-length
+           (fx+ (length (syntax (id1 ...))) 1))
+          ((index ...)
+           (let f ((i 1) (ids (syntax (id1 ...))))
+              (if (null? ids)
+                  '()
+                  (cons i (f (fx+ i 1) (cdr ids)))))))
+         (syntax (begin
+                   (define constructor
+                     (lambda (id1 ...)
+                       (vector 'name id1 ... )))
+                   (define predicate
+                     (lambda (x)
+                       (and (vector? x)
+                            (fx= (vector-length x) structure-length)
+                            (eq? (vector-ref x 0) 'name))))
+                   (define access
+                     (lambda (x)
+                       (vector-ref x index)))
+                   ...
+                   (define assign
+                     (lambda (x update)
+                       (vector-set! x index update)))
+                   ...)))))))
+
+(define-syntax let-values ; impoverished one-clause version
+  (syntax-rules ()
+    ((_ ((formals expr)) form1 form2 ...)
+     (call-with-values (lambda () expr) (lambda formals form1 form2 ...)))))
+
+(define noexpand "noexpand")
+
+(define-structure (syntax-object expression wrap))
+
+;;; hooks to nonportable run-time helpers
+(begin
+;(define-syntax fx+ (identifier-syntax +))
+;(define-syntax fx- (identifier-syntax -))
+;(define-syntax fx= (identifier-syntax =))
+;(define-syntax fx< (identifier-syntax <))
+;(define-syntax fx> (identifier-syntax >))
+;(define-syntax fx<= (identifier-syntax <=))
+;(define-syntax fx>= (identifier-syntax >=))
+
+(define annotation? (lambda (x) #f))
+(define annotation-expression 
+  (lambda (x) (error 'annotation-expression "not yet")))
+(define annotation-stripped 
+  (lambda (x) (error 'annotation-stripped "not yet")))
+
+; top-level-eval-hook is used to create "permanent" code (e.g., top-level
+; transformers), so it might be a good idea to compile it
+(define top-level-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+; local-eval-hook is used to create "temporary" code (e.g., local
+; transformers), so it might be a good idea to interpret it
+(define local-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+(define define-top-level-value-hook
+  (lambda (sym val)
+    (top-level-eval-hook
+      (build-global-definition no-source sym
+        (build-data no-source val)))))
+
+(define error-hook
+  (lambda (who why what)
+    (error who "~a ~s" why what)))
+
+(define-syntax gensym-hook
+  (syntax-rules ()
+    ((_) (gensym))))
+
+;;; AZIZ
+;;; (define put-cte-hook
+;;;   (lambda (symbol val)
+;;;     ($sc-put-cte symbol val '*top*)))
+
+(define put-cte-hook
+  (lambda (symbol val)
+    ($sc-put-cte symbol val '*top*)))
+
+(define get-global-definition-hook
+  (lambda (symbol)
+    (getprop symbol '*sc-expander*)))
+
+(define put-global-definition-hook
+  (lambda (symbol x)
+    (if (not x)
+        (remprop symbol '*sc-expander*)
+        (putprop symbol '*sc-expander* x))))
+
+; if you treat certain bindings (say from environments like ieee or r5rs)
+; read-only, this should return #t for those bindings
+(define read-only-binding?
+  (lambda (symbol)
+    #f))
+
+; should return #f if symbol has no binding for token
+(define get-import-binding
+  (lambda (symbol token)
+    (getprop symbol token)))
+
+; remove binding if x is false
+(define put-import-binding
+  (lambda (symbol token x)
+    (if (not x)
+        (remprop symbol token)
+        (putprop symbol token x))))
+
+;;; generate-id ideally produces globally unique symbols, i.e., symbols
+;;; unique across system runs, to support separate compilation/expansion.
+;;; Use gensym-hook if you do not need to support separate compilation/
+;;; expansion or if your system's gensym creates globally unique
+;;; symbols (as in Chez Scheme).  Otherwise, use the following code
+;;; as a starting point.  session-key should be a unique string for each
+;;; system run to support separate compilation; the default value given
+;;; is satisfactory during initial development only.
+;(define generate-id
+;  (let ((digits "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/:<=>?~_^.+-"))
+;    (let ((base (string-length digits)) (session-key "_"))
+;      (define make-digit (lambda (x) (string-ref digits x)))
+;      (define fmt
+;        (lambda (n)
+;          (let fmt ((n n) (a '()))
+;            (if (< n base)
+;                (list->string (cons (make-digit n) a))
+;                (let ((r (modulo n base)) (rest (quotient n base)))
+;                  (fmt rest (cons (make-digit r) a)))))))
+;      (let ((n -1))
+;        (lambda (name) ; name is #f or a symbol
+;          (set! n (+ n 1))
+;          (string->symbol (string-append session-key (fmt n))))))))
+;;; AZIZ
+(define generate-id
+  (lambda (name)
+    (if name (gensym (symbol->string name)) (gensym))))
+)
+
+
+
+;;; output constructors
+(begin
+(define-syntax build-application
+  (syntax-rules ()
+    ((_ ae fun-exp arg-exps)
+     `(,fun-exp . ,arg-exps))))
+
+(define-syntax build-conditional
+  (syntax-rules ()
+    ((_ ae test-exp then-exp else-exp)
+     `(if ,test-exp ,then-exp ,else-exp))))
+
+(define-syntax build-lexical-reference
+  (syntax-rules ()
+    ((_ type ae var)
+     var)))
+
+(define-syntax build-lexical-assignment
+  (syntax-rules ()
+    ((_ ae var exp)
+     `(set! ,var ,exp))))
+
+;;; AZIZ
+;;; (define-syntax build-global-reference
+;;;   (syntax-rules ()
+;;;     ((_ ae var)
+;;;      var)))
+(define-syntax build-global-reference
+  (syntax-rules ()
+    [(_ ae var)
+     `(top-level-value ',var)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-assignment
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(set! ,var ,exp))))
+(define-syntax build-global-assignment
+  (syntax-rules ()
+    [(_ ae var exp)
+     `(set-top-level-value! ',var ,exp)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-definition
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(define ,var ,exp))))
+(define-syntax build-global-definition
+  (syntax-rules ()
+    [(_ ae var exp)
+     (build-global-assignment ae var exp)]))
+
+
+(define-syntax build-cte-install
+ ; should build a call that has the same effect as calling put-cte-hook
+  (syntax-rules ()
+    ((_ sym exp token) 
+     `(#%$sc-put-cte ',sym ,exp ',token))))
+
+(define-syntax build-visit-only
+ ; should mark the result as "visit only" for compile-file
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+(define-syntax build-revisit-only
+ ; should mark the result as "revisit only" for compile-file,
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+;;; AZIZ
+;;; (define-syntax build-lambda
+;;;   (syntax-rules ()
+;;;     ((_ ae vars exp)
+;;;      `(lambda ,vars ,exp))))
+(define-syntax build-lambda
+  (syntax-rules ()
+    [(_ ae vars exp)
+     `(case-lambda [,vars ,exp])]))
+
+(define build-case-lambda
+  (lambda (ae vars* exp*)
+    `(case-lambda . ,(map list vars* exp*))))
+
+;;; AZIZ
+;;; (define built-lambda?
+;;;   (lambda (x)
+;;;     (and (pair? x) (eq? (car x) 'lambda))))
+(define built-lambda?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'case-lambda))))
+
+;;; AZIZ
+;;; (define-syntax build-primref
+;;;   (syntax-rules ()
+;;;     ((_ ae name) name)
+;;;     ((_ ae level name) name)))
+(define-syntax build-primref
+  (syntax-rules ()
+    [(_ ae name)       `(|#primitive| ,name)]
+    [(_ ae level name) `(|#primitive| ,name)]))
+
+
+;;; AZIZ
+(define-syntax build-foreign-call
+  (syntax-rules ()
+    [(_ ae name arg*) `(foreign-call ,name . ,arg*)]))
+(define-syntax build-$apply
+  (syntax-rules ()
+    [(_ ae proc arg*) `($apply ,proc . ,arg*)]))
+
+(define-syntax build-data
+  (syntax-rules ()
+    ((_ ae exp) `',exp)))
+
+(define build-sequence
+  (lambda (ae exps)
+    (let loop ((exps exps))
+      (if (null? (cdr exps))
+          (car exps)
+         ; weed out leading void calls, assuming ordinary list representation
+          (if (equal? (car exps) '(void))
+              (loop (cdr exps))
+              `(begin ,@exps))))))
+
+(define build-letrec
+  (lambda (ae vars val-exps body-exp)
+    (if (null? vars)
+        body-exp
+        `(letrec ,(map list vars val-exps) ,body-exp))))
+
+
+(define build-body
+  (lambda (ae vars val-exps body-exp)
+    (build-letrec ae vars val-exps body-exp)))
+
+(define build-top-module
+ ; each type is either global (exported) or local (not exported)
+ ; we produce global definitions and assignments for globals and
+ ; letrec bindings for locals.  if you don't need the definitions,
+ ; (just assignments) you can eliminate them.  if you wish to
+ ; have your module definitions ordered from left-to-right (ala
+ ; letrec*), you can replace the global var-exps with dummy vars
+ ; and global val-exps with global assignments, and produce a letrec*
+ ; in place of a letrec.
+  (lambda (ae types vars val-exps body-exp)
+    (let-values (((vars defns sets)
+                  (let f ((types types) (vars vars))
+                    (if (null? types)
+                        (values '() '() '())
+                        (let ((var (car vars)))
+                          (let-values (((vars defns sets) (f (cdr types) (cdr vars))))
+                            (if (eq? (car types) 'global)
+                                (let ((x (build-lexical-var no-source var)))
+                                  (values
+                                    (cons x vars)
+                                    (cons (build-global-definition no-source var (chi-void)) defns)
+                                    (cons (build-global-assignment no-source var (build-lexical-reference 'value no-source x)) sets)))
+                                (values (cons var vars) defns sets))))))))
+      (if (null? defns)
+          (build-letrec ae vars val-exps body-exp)
+          (build-sequence no-source
+            (append defns
+              (list
+                (build-letrec ae vars val-exps
+                  (build-sequence no-source (append sets (list body-exp)))))))))))
+
+(define-syntax build-lexical-var
+  (syntax-rules ()
+    ((_ ae id) (gensym))))
+
+(define-syntax lexical-var? gensym?)
+
+(define-syntax self-evaluating?
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (or (boolean? x) (fixnum? x) (string? x) (char? x) (null? x))))))
+)
+
+(define-syntax unannotate
+  (syntax-rules ()
+    ((_ x)
+     (let ((e x))
+       (if (annotation? e)
+           (annotation-expression e)
+           e)))))
+
+(define-syntax no-source (identifier-syntax #f))
+
+(define-syntax arg-check
+  (syntax-rules ()
+    ((_ pred? e who)
+     (let ((x e))
+       (if (not (pred? x)) (error-hook who "invalid argument" x))))))
+
+;;; compile-time environments
+
+;;; wrap and environment comprise two level mapping.
+;;;   wrap : id --> label
+;;;   env : label --> <element>
+
+;;; environments are represented in two parts: a lexical part and a global
+;;; part.  The lexical part is a simple list of associations from labels
+;;; to bindings.  The global part is implemented by
+;;; {put,get}-global-definition-hook and associates symbols with
+;;; bindings.
+
+;;; global (assumed global variable) and displaced-lexical (see below)
+;;; do not show up in any environment; instead, they are fabricated by
+;;; lookup when it finds no other bindings.
+
+;;; <environment>              ::= ((<label> . <binding>)*)
+
+;;; identifier bindings include a type and a value
+
+;;; <binding> ::= <procedure>                     macro keyword
+;;;               (macro . <procedure>)           macro keyword
+;;;               (deferred . <thunk>)            macro keyword w/lazily evaluated transformer
+;;;               (macro! . <procedure>)          extended identifier macro keyword
+;;;               (core . <procedure>)            core keyword
+;;;               (begin)                         begin keyword
+;;;               (define)                        define keyword
+;;;               (define-syntax)                 define-syntax keyword
+;;;               (local-syntax . <boolean>)      let-syntax (#f)/letrec-syntax (#t) keyword
+;;;               (eval-when)                     eval-when keyword
+;;;               (set!)                          set! keyword
+;;;               (meta)                          meta keyword
+;;;               ($module-key)                   $module keyword
+;;;               ($import)                       $import keyword
+;;;               ($module . <interface>)         modules
+;;;               (syntax . (<var> . <level>))    pattern variables
+;;;               (global . <symbol>)             assumed global variable
+;;;               (meta-variable . <symbol>)      meta variable
+;;;               (lexical . <var>)               lexical variables
+;;;               (displaced-lexical . #f)        id-var-name not found in store
+;;; <level>   ::= <nonnegative integer>
+;;; <var>     ::= variable returned by build-lexical-var
+
+;;; a macro is a user-defined syntactic-form.  a core is a system-defined
+;;; syntactic form.  begin, define, define-syntax, let-syntax, letrec-syntax,
+;;; eval-when, and meta are treated specially since they are sensitive to
+;;; whether the form is at top-level and can denote valid internal
+;;; definitions.
+
+;;; a pattern variable is a variable introduced by syntax-case and can
+;;; be referenced only within a syntax form.
+
+;;; any identifier for which no top-level syntax definition or local
+;;; binding of any kind has been seen is assumed to be a global
+;;; variable.
+
+;;; a lexical variable is a lambda- or letrec-bound variable.
+
+;;; a displaced-lexical identifier is a lexical identifier removed from
+;;; it's scope by the return of a syntax object containing the identifier.
+;;; a displaced lexical can also appear when a letrec-syntax-bound
+;;; keyword is referenced on the rhs of one of the letrec-syntax clauses.
+;;; a displaced lexical should never occur with properly written macros.
+
+(define sanitize-binding
+  (lambda (b)
+    (cond
+      ((procedure? b) (make-binding 'macro b))
+      ((binding? b)
+       (and (case (binding-type b)
+              ((core macro macro! deferred)
+               (and (procedure? (binding-value b))))
+              (($module) (interface? (binding-value b)))
+              ((lexical) (lexical-var? (binding-value b)))
+              ((global meta-variable) (symbol? (binding-value b)))
+              ((syntax) (let ((x (binding-value b)))
+                          (and (pair? x)
+                               (lexical-var? (car x))
+                               (let ((n (cdr x)))
+                                 (and (fixnum? n) (fx>= n 0))))))
+              ((begin define define-syntax set! $module-key $import eval-when meta) (null? (binding-value b)))
+              ((local-syntax) (boolean? (binding-value b)))
+              ((displaced-lexical) (eq? (binding-value b) #f))
+              (else #t))
+            b))
+      (else #f))))
+
+(define-syntax make-binding
+  (syntax-rules (quote)
+    ((_ 'type #f) '(type . #f))
+    ((_ type value) (cons type value))))
+
+(define binding-type car)
+(define binding-value cdr)
+(define set-binding-type! set-car!)
+(define set-binding-value! set-cdr!)
+(define binding? (lambda (x) (and (pair? x) (symbol? (car x)))))
+
+(define-syntax null-env (identifier-syntax '()))
+
+(define extend-env
+  (lambda (label binding r)
+    (cons (cons label binding) r)))
+
+(define extend-env*
+  (lambda (labels bindings r)
+    (if (null? labels)
+        r
+        (extend-env* (cdr labels) (cdr bindings)
+          (extend-env (car labels) (car bindings) r)))))
+
+(define extend-var-env*
+  ; variant of extend-env* that forms "lexical" binding
+  (lambda (labels vars r)
+    (if (null? labels)
+        r
+        (extend-var-env* (cdr labels) (cdr vars)
+          (extend-env (car labels) (make-binding 'lexical (car vars)) r)))))
+
+(define (displaced-lexical? id r)
+  (let ((n (id-var-name id empty-wrap)))
+    (and n
+         (let ((b (lookup n r)))
+           (eq? (binding-type b) 'displaced-lexical)))))
+
+(define displaced-lexical-error
+  (lambda (id)
+    (syntax-error id
+      (if (id-var-name id empty-wrap)
+          "identifier out of context"
+          "identifier not visible"))))
+
+(define lookup*
+  ; x may be a label or a symbol
+  ; although symbols are usually global, we check the environment first
+  ; anyway because a temporary binding may have been established by
+  ; fluid-let-syntax
+  (lambda (x r)
+    (cond
+      ((assq x r) => cdr)
+      ((symbol? x)
+       (or (get-global-definition-hook x) (make-binding 'global x)))
+      (else (make-binding 'displaced-lexical #f)))))
+
+(define lookup
+  (lambda (x r)
+    (define whack-binding!
+      (lambda (b *b)
+        (set-binding-type! b (binding-type *b))
+        (set-binding-value! b (binding-value *b))))
+    (let ((b (lookup* x r)))
+      (when (eq? (binding-type b) 'deferred)
+        (whack-binding! b (make-transformer-binding ((binding-value b)))))
+      b)))
+
+(define make-transformer-binding
+  (lambda (b)
+    (or (sanitize-binding b)
+        (syntax-error b "invalid transformer"))))
+
+(define defer-or-eval-transformer
+  (lambda (eval x)
+    (if (built-lambda? x)
+        (make-binding 'deferred (lambda () (eval x)))
+        (make-transformer-binding (eval x)))))
+
+(define global-extend
+  (lambda (type sym val)
+    (put-cte-hook sym (make-binding type val))))
+
+
+;;; Conceptually, identifiers are always syntax objects.  Internally,
+;;; however, the wrap is sometimes maintained separately (a source of
+;;; efficiency and confusion), so that symbols are also considered
+;;; identifiers by id?.  Externally, they are always wrapped.
+
+(define nonsymbol-id?
+  (lambda (x)
+    (and (syntax-object? x)
+         (symbol? (unannotate (syntax-object-expression x))))))
+
+(define id?
+  (lambda (x)
+    (cond
+      ((symbol? x) #t)
+      ((syntax-object? x) (symbol? (unannotate (syntax-object-expression x))))
+      ((annotation? x) (symbol? (annotation-expression x)))
+      (else #f))))
+
+(define-syntax id-sym-name
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (unannotate (if (syntax-object? x) (syntax-object-expression x) x))))))
+
+(define id-marks
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-marks (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-subst
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-subst (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-sym-name&marks
+  (lambda (x w)
+    (if (syntax-object? x)
+        (values
+          (unannotate (syntax-object-expression x))
+          (join-marks (wrap-marks w) (wrap-marks (syntax-object-wrap x))))
+        (values (unannotate x) (wrap-marks w)))))
+
+;;; syntax object wraps
+
+;;;         <wrap>     ::= ((<mark> ...) . (<subst> ...))
+;;;        <subst>     ::= <ribcage> | <shift>
+;;;      <ribcage>     ::= #((<ex-symname> ...) (<mark> ...) (<label> ...)) ; extensible, for chi-internal/external
+;;;                      | #(#(<symname> ...) #(<mark> ...) #(<label> ...)) ; nonextensible
+;;;   <ex-symname>     ::= <symname> | <import token> | <barrier>
+;;;        <shift>     ::= shift
+;;;      <barrier>     ::= #f                                               ; inserted by import-only
+;;; <import interface> ::= #<import-interface interface new-marks>
+;;;        <token>     ::= <generated id>
+
+(define make-wrap cons)
+(define wrap-marks car)
+(define wrap-subst cdr)
+
+
+(define-syntax empty-wrap (identifier-syntax '(())))
+
+(define-syntax top-wrap (identifier-syntax '((top))))
+
+(define-syntax top-marked?
+  (syntax-rules ()
+    ((_ w) (memq 'top (wrap-marks w)))))
+
+(define-syntax only-top-marked?
+  (syntax-rules ()
+    ((_ id) (same-marks? (wrap-marks (syntax-object-wrap id)) (wrap-marks top-wrap)))))
+
+;;; labels
+
+;;; simple labels must be comparable with "eq?" and distinct from symbols
+;;; and pairs.
+
+;;; indirect labels, which are implemented as pairs, are used to support
+;;; import aliasing for identifiers exported (explictly or implicitly) from
+;;; top-level modules.  chi-external creates an indirect label for each
+;;; defined identifier, import causes the pair to be shared with aliases it
+;;; establishes, and chi-top-module whacks the pair to hold the top-level
+;;; identifier name (symbol) if the id is to be placed at top level, before
+;;; expanding the right-hand sides of the definitions in the module.
+
+(module (gen-indirect-label indirect-label? get-indirect-label set-indirect-label!)
+  (define-structure (indirect-label label))
+  (define gen-indirect-label
+    (lambda ()
+      (make-indirect-label (gen-label))))
+  (define get-indirect-label (lambda (x) (indirect-label-label x)))
+  (define set-indirect-label! (lambda (x v) (set-indirect-label-label! x v))))
+
+(define gen-label
+  (lambda () (string #\i)))
+(define label?
+  (lambda (x)
+    (or (string? x) ; normal lexical labels
+        (symbol? x) ; global labels (symbolic names)
+        (indirect-label? x))))
+
+(define gen-labels
+  (lambda (ls)
+    (if (null? ls)
+        '()
+        (cons (gen-label) (gen-labels (cdr ls))))))
+
+(define-structure (ribcage symnames marks labels))
+(define-structure (top-ribcage key mutable?))
+(define-structure (import-interface interface new-marks))
+(define-structure (env top-ribcage wrap))
+
+;;; Marks must be comparable with "eq?" and distinct from pairs and
+;;; the symbol top.  We do not use integers so that marks will remain
+;;; unique even across file compiles.
+
+(define-syntax the-anti-mark (identifier-syntax #f))
+
+(define anti-mark
+  (lambda (w)
+    (make-wrap (cons the-anti-mark (wrap-marks w))
+               (cons 'shift (wrap-subst w)))))
+
+(define-syntax new-mark
+  (syntax-rules ()
+    ((_) (string #\m))))
+
+(define barrier-marker #f)
+
+;;; make-empty-ribcage and extend-ribcage maintain list-based ribcages for
+;;; internal definitions, in which the ribcages are built incrementally
+(define-syntax make-empty-ribcage
+  (syntax-rules ()
+    ((_) (make-ribcage '() '() '()))))
+
+(define extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks (syntax-object-wrap id))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define import-extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage new-marks id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (join-marks new-marks (wrap-marks (syntax-object-wrap id)))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define extend-ribcage-barrier!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage killer-id)
+    (extend-ribcage-barrier-help! ribcage (syntax-object-wrap killer-id))))
+
+(define extend-ribcage-barrier-help!
+  (lambda (ribcage wrap)
+    (set-ribcage-symnames! ribcage
+      (cons barrier-marker (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks wrap) (ribcage-marks ribcage)))))
+
+(define extend-ribcage-subst!
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage import-iface)
+    (set-ribcage-symnames! ribcage
+      (cons import-iface (ribcage-symnames ribcage)))))
+
+(define lookup-import-binding-name
+  (lambda (sym marks token new-marks)
+    (let ((new (get-import-binding sym token)))
+      (and new
+           (let f ((new new))
+             (cond
+               ((pair? new) (or (f (car new)) (f (cdr new))))
+               ((symbol? new)
+                (and (same-marks? marks (join-marks new-marks (wrap-marks top-wrap))) new))
+               ((same-marks? marks (join-marks new-marks (wrap-marks (syntax-object-wrap new)))) new)
+               (else #f)))))))
+  
+(define store-import-binding
+  (lambda (id token new-marks)
+    (define cons-id
+      (lambda (id x)
+        (if (not x) id (cons id x))))
+    (define weed ; remove existing binding for id, if any
+      (lambda (marks x)
+        (if (pair? x)
+            (if (same-marks? (id-marks (car x)) marks)
+                (weed marks (cdr x))
+                (cons-id (car x) (weed marks (cdr x))))
+            (and x (not (same-marks? (id-marks x) marks)) x))))
+    (let ((id (if (null? new-marks)
+                  id
+                  (make-syntax-object (id-sym-name id)
+                    (make-wrap
+                      (join-marks new-marks (id-marks id))
+                      (id-subst id))))))
+      (let ((sym (id-sym-name id)))
+       ; no need to record bindings mapping symbol to self, since this   
+       ; assumed by default.
+        (unless (eq? id sym)
+          (let ((marks (id-marks id)))
+            (let ((x (weed marks (get-import-binding sym token))))
+              (put-import-binding sym token
+                (cons-id
+                  (if (same-marks? marks (wrap-marks top-wrap))
+                     ; need full id only if more than top-marked.
+                      (resolved-id-var-name id)
+                      id)
+                  x)))))))))
+
+;;; make-binding-wrap creates vector-based ribcages
+(define make-binding-wrap
+  (lambda (ids labels w)
+    (if (null? ids)
+        w
+        (make-wrap
+          (wrap-marks w)
+          (cons
+            (let ((labelvec (list->vector labels)))
+              (let ((n (vector-length labelvec)))
+                (let ((symnamevec (make-vector n)) (marksvec (make-vector n)))
+                  (let f ((ids ids) (i 0))
+                    (unless (null? ids)
+                      (let-values (((symname marks) (id-sym-name&marks (car ids) w)))
+                        (vector-set! symnamevec i symname)
+                        (vector-set! marksvec i marks)
+                        (f (cdr ids) (fx+ i 1)))))
+                  (make-ribcage symnamevec marksvec labelvec))))
+            (wrap-subst w))))))
+
+;;; resolved ids contain no unnecessary substitutions or marks.  they are
+;;; used essentially as indirects or aliases in modules interfaces.
+(define make-resolved-id
+  (lambda (fromsym marks tosym)
+    (make-syntax-object fromsym
+      (make-wrap marks
+        (list (make-ribcage (vector fromsym) (vector marks) (vector tosym)))))))
+
+(define id->resolved-id
+  (lambda (id)
+    (let-values (((tosym marks) (id-var-name&marks id empty-wrap)))
+      (unless tosym
+        (syntax-error id "identifier not visible for export"))
+      (make-resolved-id (id-sym-name id) marks tosym))))
+
+(define resolved-id-var-name
+  (lambda (id)
+    (vector-ref
+      (ribcage-labels (car (wrap-subst (syntax-object-wrap id))))
+      0)))
+
+;;; Scheme's append should not copy the first argument if the second is
+;;; nil, but it does, so we define a smart version here.
+(define smart-append
+  (lambda (m1 m2)
+    (if (null? m2)
+        m1
+        (append m1 m2))))
+
+(define join-wraps
+  (lambda (w1 w2)
+    (let ((m1 (wrap-marks w1)) (s1 (wrap-subst w1)))
+      (if (null? m1)
+          (if (null? s1)
+              w2
+              (make-wrap
+                (wrap-marks w2)
+                (join-subst s1 (wrap-subst w2))))
+          (make-wrap
+            (join-marks m1 (wrap-marks w2))
+            (join-subst s1 (wrap-subst w2)))))))
+
+(define join-marks
+  (lambda (m1 m2)
+    (smart-append m1 m2)))
+
+(define join-subst
+  (lambda (s1 s2)
+    (smart-append s1 s2)))
+
+(define same-marks?
+  (lambda (x y)
+    (or (eq? x y)
+        (and (not (null? x))
+             (not (null? y))
+             (eq? (car x) (car y))
+             (same-marks? (cdr x) (cdr y))))))
+
+(define diff-marks
+  (lambda (m1 m2)
+    (let ((n1 (length m1)) (n2 (length m2)))
+      (let f ((n1 n1) (m1 m1))
+        (cond
+          ((fx> n1 n2) (cons (car m1) (f (fx- n1 1) (cdr m1))))
+          ((equal? m1 m2) '())
+          (else (error 'sc-expand
+                  "internal error in diff-marks: ~s is not a tail of ~s"
+                  m1 m2)))))))
+
+(module (top-id-bound-var-name top-id-free-var-name)
+  ;; top-id-bound-var-name is used to look up or establish new top-level
+  ;; substitutions, while top-id-free-var-name is used to look up existing
+  ;; (possibly implicit) substitutions.  Implicit substitutions exist
+  ;; for top-marked names in all environments, but we represent them
+  ;; explicitly only on demand.
+  ;;
+  ;; In both cases, we first look for an existing substitution for sym
+  ;; and the given marks.  If we find one, we return it.  Otherwise, we
+  ;; extend the appropriate top-level environment
+  ;;
+  ;; For top-id-bound-var-name, we extend the environment with a substition
+  ;; keyed by the given marks, so that top-level definitions introduced by
+  ;; a macro are distinct from other top-level definitions for the same
+  ;; name.  For example, if macros a and b both introduce definitions and
+  ;; bound references to identifier x, the two x's should be different,
+  ;; i.e., keyed by their own marks.
+  ;;
+  ;; For top-id-free-var-name, we extend the environment with a substition
+  ;; keyed by the top marks, since top-level free identifier references
+  ;; should refer to the existing implicit (top-marked) substitution.  For
+  ;; example, if macros a and b both introduce free references to identifier
+  ;; x, they should both refer to the same (global, unmarked) x.
+  ;;
+ ;; If the environment is *top*, we map a symbol to itself
+
+ (define leave-implicit? (lambda (token) (eq? token '*top*)))
+
+  (define new-binding
+    (lambda (sym marks token)
+      (let ((loc (if (and (leave-implicit? token)
+                          (same-marks? marks (wrap-marks top-wrap)))
+                     sym
+                     (generate-id sym))))
+        (let ((id (make-resolved-id sym marks loc)))
+          (store-import-binding id token '())
+          (values loc id)))))
+
+  (define top-id-bound-var-name
+   ; should be called only when top-ribcage is mutable
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id)
+             (if (symbol? id) ; symbol iff marks == (wrap-marks top-wrap)
+                 (if (read-only-binding? id)
+                     (new-binding sym marks token)
+                     (values id (make-resolved-id sym marks id)))
+                 (values (resolved-id-var-name id) id))))
+          (else (new-binding sym marks token))))))
+
+  (define top-id-free-var-name
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id) (if (symbol? id) id (resolved-id-var-name id))))
+          ((and (top-ribcage-mutable? top-ribcage)
+                (same-marks? marks (wrap-marks top-wrap)))
+           (let-values (((sym id) (new-binding sym (wrap-marks top-wrap) token)))
+             sym))
+          (else #f))))))
+
+(define id-var-name-loc&marks
+  (lambda (id w)
+    (define search
+      (lambda (sym subst marks)
+        (if (null? subst)
+            (values #f marks)
+            (let ((fst (car subst)))
+               (cond
+                 ((eq? fst 'shift) (search sym (cdr subst) (cdr marks)))
+                 ((ribcage? fst)
+                  (let ((symnames (ribcage-symnames fst)))
+                    (if (vector? symnames)
+                        (search-vector-rib sym subst marks symnames fst)
+                        (search-list-rib sym subst marks symnames fst))))
+                 ((top-ribcage? fst)
+                  (cond
+                    ((top-id-free-var-name sym marks fst) =>
+                     (lambda (var-name) (values var-name marks)))
+                    (else (search sym (cdr subst) marks))))
+                 (else
+                  (error 'sc-expand
+                    "internal error in id-var-name-loc&marks: improper subst ~s"
+                    subst)))))))
+    (define search-list-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let f ((symnames symnames) (i 0))
+          (if (null? symnames)
+              (search sym (cdr subst) marks)
+              (let ((x (car symnames)))
+                (cond
+                  ((and (eq? x sym)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values (list-ref (ribcage-labels ribcage) i) marks))
+                  ((import-interface? x)
+                   (let ((iface (import-interface-interface x))
+                         (new-marks (import-interface-new-marks x)))
+                     (cond
+                       ((interface-token iface) =>
+                        (lambda (token)
+                          (cond
+                            ((lookup-import-binding-name sym marks token new-marks) =>
+                             (lambda (id)
+                               (values
+                                 (if (symbol? id) id (resolved-id-var-name id))
+                                 marks)))
+                            (else (f (cdr symnames) i)))))
+                       (else
+                        (let* ((ie (interface-exports iface))
+                               (n (vector-length ie)))
+                          (let g ((j 0))
+                            (if (fx= j n)
+                                (f (cdr symnames) i)
+                                (let ((id (vector-ref ie j)))
+                                  (let ((id.sym (id-sym-name id))
+                                        (id.marks (join-marks new-marks (id-marks id))))
+                                    (if (help-bound-id=? id.sym id.marks sym marks)
+                                        (values (lookup-import-label id) marks)
+                                        (g (fx+ j 1))))))))))))
+                  ((and (eq? x barrier-marker)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values #f marks))
+                  (else (f (cdr symnames) (fx+ i 1)))))))))
+    (define search-vector-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let ((n (vector-length symnames)))
+          (let f ((i 0))
+            (cond
+              ((fx= i n) (search sym (cdr subst) marks))
+              ((and (eq? (vector-ref symnames i) sym)
+                    (same-marks? marks (vector-ref (ribcage-marks ribcage) i)))
+               (values (vector-ref (ribcage-labels ribcage) i) marks))
+              (else (f (fx+ i 1))))))))
+    (cond
+      ((symbol? id) (search id (wrap-subst w) (wrap-marks w)))
+      ((syntax-object? id)
+       (let ((sym (unannotate (syntax-object-expression id)))
+             (w1 (syntax-object-wrap id)))
+         (let-values (((name marks) (search sym (wrap-subst w)
+                                      (join-marks
+                                        (wrap-marks w)
+                                        (wrap-marks w1)))))
+           (if name
+               (values name marks)
+               (search sym (wrap-subst w1) marks)))))
+      ((annotation? id) (search (unannotate id) (wrap-subst w) (wrap-marks w)))
+      (else (error-hook 'id-var-name "invalid id" id)))))
+
+(define id-var-name&marks
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (values (if (indirect-label? label) (get-indirect-label label) label) marks))))
+
+(define id-var-name-loc
+ ; this version doesn't follow indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      label)))
+
+(define id-var-name
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (if (indirect-label? label) (get-indirect-label label) label))))
+
+;;; free-id=? must be passed fully wrapped ids since (free-id=? x y)
+;;; may be true even if (free-id=? (wrap x w) (wrap y w)) is not.
+
+(define free-id=?
+  (lambda (i j)
+    (and (eq? (id-sym-name i) (id-sym-name j)) ; accelerator
+         (eq? (id-var-name i empty-wrap) (id-var-name j empty-wrap)))))
+
+(define literal-id=?
+  (lambda (id literal)
+    (and (eq? (id-sym-name id) (id-sym-name literal))
+         (let ((n-id (id-var-name id empty-wrap))
+               (n-literal (id-var-name literal empty-wrap)))
+           (or (eq? n-id n-literal)
+               (and (or (not n-id) (symbol? n-id))
+                    (or (not n-literal) (symbol? n-literal))))))))
+
+;;; bound-id=? may be passed unwrapped (or partially wrapped) ids as
+;;; long as the missing portion of the wrap is common to both of the ids
+;;; since (bound-id=? x y) iff (bound-id=? (wrap x w) (wrap y w))
+
+(define help-bound-id=?
+  (lambda (i.sym i.marks j.sym j.marks)
+    (and (eq? i.sym j.sym)
+         (same-marks? i.marks j.marks))))
+   
+(define bound-id=?
+  (lambda (i j)
+    (help-bound-id=? (id-sym-name i) (id-marks i) (id-sym-name j) (id-marks j))))
+
+;;; "valid-bound-ids?" returns #t if it receives a list of distinct ids.
+;;; valid-bound-ids? may be passed unwrapped (or partially wrapped) ids
+;;; as long as the missing portion of the wrap is common to all of the
+;;; ids.
+
+(define valid-bound-ids?
+  (lambda (ids)
+     (and (let all-ids? ((ids ids))
+            (or (null? ids)
+                (and (id? (car ids))
+                     (all-ids? (cdr ids)))))
+          (distinct-bound-ids? ids))))
+
+;;; distinct-bound-ids? expects a list of ids and returns #t if there are
+;;; no duplicates.  It is quadratic on the length of the id list; long
+;;; lists could be sorted to make it more efficient.  distinct-bound-ids?
+;;; may be passed unwrapped (or partially wrapped) ids as long as the
+;;; missing portion of the wrap is common to all of the ids.
+
+(define distinct-bound-ids?
+  (lambda (ids)
+    (let distinct? ((ids ids))
+      (or (null? ids)
+          (and (not (bound-id-member? (car ids) (cdr ids)))
+               (distinct? (cdr ids)))))))
+
+(define invalid-ids-error
+ ; find first bad one and complain about it
+  (lambda (ids exp class)
+    (let find ((ids ids) (gooduns '()))
+      (if (null? ids)
+          (syntax-error exp) ; shouldn't happen
+          (if (id? (car ids))
+              (if (bound-id-member? (car ids) gooduns)
+                  (syntax-error (car ids) "duplicate " class)
+                  (find (cdr ids) (cons (car ids) gooduns)))
+              (syntax-error (car ids) "invalid " class))))))
+
+(define bound-id-member?
+   (lambda (x list)
+      (and (not (null? list))
+           (or (bound-id=? x (car list))
+               (bound-id-member? x (cdr list))))))
+
+;;; wrapping expressions and identifiers
+
+(define wrap
+  (lambda (x w)
+    (cond
+      ((and (null? (wrap-marks w)) (null? (wrap-subst w))) x)
+      ((syntax-object? x)
+       (make-syntax-object
+         (syntax-object-expression x)
+         (join-wraps w (syntax-object-wrap x))))
+      ((null? x) x)
+      (else (make-syntax-object x w)))))
+
+(define source-wrap
+  (lambda (x w ae)
+    (wrap (if (annotation? ae)
+              (begin
+                (unless (eq? (annotation-expression ae) x)
+                  (error 'sc-expand "internal error in source-wrap: ae/x mismatch"))
+                ae)
+              x)
+          w)))
+
+;;; expanding
+
+(define chi-when-list
+  (lambda (when-list w)
+    ; when-list is syntax'd version of list of situations
+    (map (lambda (x)
+           (cond
+             ((literal-id=? x (syntax compile)) 'compile)
+             ((literal-id=? x (syntax load)) 'load)
+             ((literal-id=? x (syntax visit)) 'visit)
+             ((literal-id=? x (syntax revisit)) 'revisit)
+             ((literal-id=? x (syntax eval)) 'eval)
+             (else (syntax-error (wrap x w) "invalid eval-when situation"))))
+         when-list)))
+
+;;; syntax-type returns five values: type, value, e, w, and ae.  The first
+;;; two are described in the table below.
+;;;
+;;;    type                   value         explanation
+;;;    -------------------------------------------------------------------
+;;;    alias                  none          alias keyword
+;;;    alias-form             none          alias expression
+;;;    begin                  none          begin keyword
+;;;    begin-form             none          begin expression
+;;;    call                   none          any other call
+;;;    constant               none          self-evaluating datum
+;;;    core                   procedure     core form (including singleton)
+;;;    define                 none          define keyword
+;;;    define-form            none          variable definition
+;;;    define-syntax          none          define-syntax keyword
+;;;    define-syntax-form     none          syntax definition
+;;;    displaced-lexical      none          displaced lexical identifier
+;;;    eval-when              none          eval-when keyword
+;;;    eval-when-form         none          eval-when form
+;;;    global                 name          global variable reference
+;;;    $import                none          $import keyword
+;;;    $import-form           none          $import form
+;;;    lexical                name          lexical variable reference
+;;;    lexical-call           name          call to lexical variable
+;;;    local-syntax           rec?          letrec-syntax/let-syntax keyword
+;;;    local-syntax-form      rec?          syntax definition
+;;;    meta                   none          meta keyword
+;;;    meta-form              none          meta form
+;;;    meta-variable          name          meta variable
+;;;    $module                none          $module keyword
+;;;    $module-form           none          $module definition
+;;;    syntax                 level         pattern variable
+;;;    other                  none          anything else
+;;;
+;;; For all forms, e is the form, w is the wrap for e. and ae is the
+;;; (possibly) source-annotated form.
+;;;
+;;; syntax-type expands macros and unwraps as necessary to get to
+;;; one of the forms above.
+
+(define syntax-type
+  (lambda (e r w ae rib)
+    (cond
+      ((symbol? e)
+       (let* ((n (id-var-name e w))
+              (b (lookup n r))
+              (type (binding-type b)))
+         (case type
+           ((macro macro!) (syntax-type (chi-macro (binding-value b) e r w ae rib) r empty-wrap #f rib))
+           (else (values type (binding-value b) e w ae)))))
+      ((pair? e)
+       (let ((first (car e)))
+         (if (id? first)
+             (let* ((n (id-var-name first w))
+                    (b (lookup n r))
+                    (type (binding-type b)))
+               (case type
+                 ((lexical) (values 'lexical-call (binding-value b) e w ae))
+                 ((macro macro!)
+                  (syntax-type (chi-macro (binding-value b) e r w ae rib)
+                    r empty-wrap #f rib))
+                 ((core) (values type (binding-value b) e w ae))
+                 ((begin) (values 'begin-form #f e w ae))
+                 ((alias) (values 'alias-form #f e w ae))
+                 ((define) (values 'define-form #f e w ae))
+                 ((define-syntax) (values 'define-syntax-form #f e w ae))
+                 ((set!) (chi-set! e r w ae rib))
+                 (($module-key) (values '$module-form #f e w ae))
+                 (($import) (values '$import-form #f e w ae))
+                 ((eval-when) (values 'eval-when-form #f e w ae))
+                 ((meta) (values 'meta-form #f e w ae))
+                 ((local-syntax)
+                  (values 'local-syntax-form (binding-value b) e w ae))
+                 (else (values 'call #f e w ae))))
+             (values 'call #f e w ae))))
+      ((syntax-object? e)
+       (syntax-type (syntax-object-expression e)
+                    r
+                    (join-wraps w (syntax-object-wrap e))
+                    #f rib))
+      ((annotation? e)
+       (syntax-type (annotation-expression e) r w e rib))
+      ((self-evaluating? e) (values 'constant #f e w ae))
+      (else (values 'other #f e w ae)))))
+
+(define chi-top*
+  (lambda (e r w ctem rtem meta? top-ribcage)
+    (let ((meta-residuals '()))
+      (define meta-residualize!
+        (lambda (x)
+          (set! meta-residuals
+            (cons x meta-residuals))))
+      (let ((e (chi-top e r w ctem rtem meta? top-ribcage meta-residualize! #f)))
+        (build-sequence no-source
+          (reverse (cons e meta-residuals)))))))
+
+(define chi-top-sequence
+  (lambda (body r w ae ctem rtem meta? ribcage meta-residualize!)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi-top (car body) r w ctem rtem meta? ribcage meta-residualize! #f)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi-top
+  (lambda (e r w ctem rtem meta? top-ribcage meta-residualize! meta-seen?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source top-ribcage)))
+      (case type
+        ((begin-form)
+         (let ((forms (parse-begin e w ae #t)))
+           (if (null? forms)
+               (chi-void)
+               (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!))))
+        ((local-syntax-form)
+         (let-values (((forms r mr w ae) (chi-local-syntax value e r r w ae)))
+          ; mr should be same as r here
+           (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))
+        ((eval-when-form)
+         (let-values (((when-list forms) (parse-eval-when e w ae)))
+           (let ((ctem (update-mode-set when-list ctem))
+                 (rtem (update-mode-set when-list rtem)))
+             (if (and (null? ctem) (null? rtem))
+                 (chi-void)
+                 (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))))
+        ((meta-form) (chi-top (parse-meta e w ae) r w ctem rtem #t top-ribcage meta-residualize! #t))
+        ((define-syntax-form)
+         (let-values (((id rhs w) (parse-define-syntax e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       bound-id
+                       (chi rhs r r w #t)
+                       (top-ribcage-key top-ribcage)))))))))
+        ((define-form)
+         (let-values (((id rhs w) (parse-define e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (if meta?
+                     (ct-eval/residualize2 ctem
+                       (lambda ()
+                         (build-sequence no-source
+                           (list
+                             (build-cte-install bound-id
+                               (build-data no-source (make-binding 'meta-variable valsym))
+                               (top-ribcage-key top-ribcage))
+                             (build-global-definition ae valsym (chi rhs r r w #t))))))
+                    ; make sure compile-time definitions occur before we
+                    ; expand the run-time code
+                     (let ((x (ct-eval/residualize2 ctem
+                                (lambda ()
+                                  (build-cte-install
+                                    bound-id
+                                    (build-data no-source (make-binding 'global valsym))
+                                    (top-ribcage-key top-ribcage))))))
+                       (build-sequence no-source
+                         (list
+                           x
+                           (rt-eval/residualize rtem
+                             (lambda ()
+                               (build-global-definition ae valsym (chi rhs r r w #f)))))))))
+             ))))
+        (($module-form)
+         (let ((ribcage (make-empty-ribcage)))
+           (let-values (((orig id exports forms)
+                         (parse-module e w ae
+                           (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))))
+             (when (displaced-lexical? id r) (displaced-lexical-error (wrap id w)))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error orig
+                 "invalid definition in read-only environment"))
+             (chi-top-module orig r r top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!))))
+        (($import-form)
+         (let-values (((orig only? mid) (parse-import e w ae)))
+           (unless (top-ribcage-mutable? top-ribcage)
+             (syntax-error orig
+               "invalid definition in read-only environment"))
+           (ct-eval/residualize2 ctem
+             (lambda ()
+               (let ((binding (lookup (id-var-name mid empty-wrap) null-env)))
+                 (case (binding-type binding)
+                   (($module) (do-top-import only? top-ribcage mid (interface-token (binding-value binding))))
+                   ((displaced-lexical) (displaced-lexical-error mid))
+                   (else (syntax-error mid "unknown module"))))))))
+        ((alias-form)
+         (let-values (((new-id old-id) (parse-alias e w ae)))
+           (let ((new-id (wrap new-id w)))
+             (when (displaced-lexical? new-id r) (displaced-lexical-error new-id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name new-id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap new-id)) top-ribcage)))
+                 (unless (eq? (id-var-name new-id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       (make-resolved-id sym (wrap-marks (syntax-object-wrap new-id)) (id-var-name old-id w))
+                       (build-data no-source (make-binding 'do-alias #f))
+                       (top-ribcage-key top-ribcage)))))))))
+        (else
+         (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+         (if meta?
+             (let ((x (chi-expr type value e r r w ae #t)))
+               (top-level-eval-hook x)
+               (ct-eval/residualize3 ctem void (lambda () x)))
+             (rt-eval/residualize rtem
+               (lambda ()
+                 (chi-expr type value e r r w ae #f)))))))))
+
+(define flatten-exports
+  (lambda (exports)
+    (let loop ((exports exports) (ls '()))
+      (if (null? exports)
+          ls
+          (loop (cdr exports)
+                (if (pair? (car exports))
+                    (loop (car exports) ls)
+                    (cons (car exports) ls)))))))
+
+
+(define-structure (interface marks exports token))
+
+;; leaves interfaces unresolved so that indirect labels can be followed.
+;; (can't resolve until indirect labels have their final value)
+(define make-unresolved-interface
+ ; trim out implicit exports
+  (lambda (mid exports)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (if (pair? x) (car x) x)) exports))
+      #f)))
+
+(define make-resolved-interface
+ ; trim out implicit exports & resolve others to actual top-level symbol
+  (lambda (mid exports token)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (id->resolved-id (if (pair? x) (car x) x))) exports))
+      token)))
+
+(define-structure (module-binding type id label imps val exported))
+(define create-module-binding
+  (lambda (type id label imps val)
+    (make-module-binding type id label imps val #f)))
+
+;;; frobs represent body forms
+(define-structure (frob e meta?))
+
+(define chi-top-module
+  (lambda (orig r mr top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!)
+    (let ((fexports (flatten-exports exports)))
+      (let-values (((r mr bindings inits)
+                    (chi-external ribcage orig
+                      (map (lambda (d) (make-frob d meta?)) forms) r mr ctem exports fexports
+                      meta-residualize!)))
+       ; identify exported identifiers, create ctdefs
+        (let process-exports ((fexports fexports) (ctdefs (lambda () '())))
+          (if (null? fexports)
+             ; remaining bindings are either identified global vars,
+             ; local vars, or local compile-time entities
+             ; dts: type (local/global)
+             ; dvs & des: define lhs & rhs
+              (let process-locals ((bs bindings) (r r) (dts '()) (dvs '()) (des '()))
+                (if (null? bs)
+                    (let ((des (chi-frobs des r mr #f))
+                          (inits (chi-frobs inits r mr #f)))
+                      (build-sequence no-source
+                        (append
+                         ; we wait to establish global compile-time definitions so that
+                         ; expansion of des use local versions of modules and macros
+                         ; in case ctem tells us not to eval ctdefs now.  this means that
+                         ; local code can use exported compile-time values (modules, macros,
+                         ; meta variables) just as it can unexported ones.
+                          (ctdefs)
+                          (list
+                            (ct-eval/residualize2 ctem
+                              (lambda ()
+                                (let ((sym (id-sym-name id)))
+                                  (let* ((token (generate-id sym))
+                                         (b (build-data no-source
+                                              (make-binding '$module
+                                                (make-resolved-interface id exports token)))))
+                                    (let-values (((valsym bound-id)
+                                                  (top-id-bound-var-name sym
+                                                    (wrap-marks (syntax-object-wrap id))
+                                                    top-ribcage)))
+                                      (unless (eq? (id-var-name id empty-wrap) valsym)
+                                        (syntax-error orig
+                                          "definition not permitted"))
+                                      (when (read-only-binding? valsym)
+                                        (syntax-error orig
+                                          "invalid definition of read-only identifier"))
+                                      (build-cte-install bound-id b
+                                        (top-ribcage-key top-ribcage)))))))
+                            (rt-eval/residualize rtem
+                              (lambda ()
+                                (build-top-module no-source dts dvs des
+                                  (if (null? inits)
+                                      (chi-void)
+                                      (build-sequence no-source
+                                        (append inits (list (chi-void))))))))))))
+                    (let ((b (car bs)) (bs (cdr bs)))
+                      (let ((t (module-binding-type b)))
+                        (case (module-binding-type b)
+                          ((define-form)
+                           (let ((label (get-indirect-label (module-binding-label b))))
+                             (if (module-binding-exported b)
+                                 (let ((var (module-binding-id b)))
+                                   (process-locals bs r (cons 'global dts) (cons label dvs)
+                                     (cons (module-binding-val b) des)))
+                                 (let ((var (gen-var (module-binding-id b))))
+                                   (process-locals bs
+                                    ; add lexical bindings only to run-time environment
+                                     (extend-env label (make-binding 'lexical var) r)
+                                     (cons 'local dts) (cons var dvs)
+                                     (cons (module-binding-val b) des))))))
+                          ((ctdefine-form define-syntax-form $module-form alias-form) (process-locals bs r dts dvs des))
+                          (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))))
+              (let ((id (car fexports)) (fexports (cdr fexports)))
+                (let loop ((bs bindings))
+                  (if (null? bs)
+                     ; must be rexport from an imported module
+                      (process-exports fexports ctdefs)
+                      (let ((b (car bs)) (bs (cdr bs)))
+                       ; following formerly used bound-id=?, but free-id=? can prevent false positives
+                       ; and is okay since the substitutions have already been applied
+                        (if (free-id=? (module-binding-id b) id)
+                            (if (module-binding-exported b)
+                                (process-exports fexports ctdefs)
+                                (let* ((t (module-binding-type b))
+                                       (label (module-binding-label b))
+                                       (imps (module-binding-imps b))
+                                       (fexports (append imps fexports)))
+                                  (set-module-binding-exported! b #t)
+                                  (case t
+                                    ((define-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (set-indirect-label! label sym)
+                                       (process-exports fexports ctdefs)))
+                                    ((ctdefine-form)
+                                     (let ((b (module-binding-val b)))
+                                       (process-exports fexports
+                                         (lambda ()
+                                           (let ((sym (binding-value b)))
+                                             (set-indirect-label! label sym)
+                                             (cons (ct-eval/residualize3 ctem
+                                                     (lambda () (put-cte-hook sym b))
+                                                     (lambda () (build-cte-install sym (build-data no-source b) #f)))
+                                                   (ctdefs)))))))
+                                    ((define-syntax-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (process-exports fexports
+                                         (lambda () 
+                                           (let ((local-label (get-indirect-label label)))
+                                             (set-indirect-label! label sym)
+                                             (cons
+                                               (ct-eval/residualize3 ctem
+                                                 (lambda () (put-cte-hook sym (car (module-binding-val b))))
+                                                 (lambda () (build-cte-install sym (cdr (module-binding-val b)) #f)))
+                                               (ctdefs)))))))
+                                    (($module-form)
+                                     (let ((sym (generate-id (id-sym-name id)))
+                                           (exports (module-binding-val b)))
+                                       (process-exports (append (flatten-exports exports) fexports)
+                                         (lambda ()
+                                           (set-indirect-label! label sym)
+                                           (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                             (let ((x (make-binding '$module (make-resolved-interface id exports sym))))
+                                               (cons (ct-eval/residualize3 ctem
+                                                       (lambda () (put-cte-hook sym x))
+                                                       (lambda () (build-cte-install sym (build-data no-source x) #f)))
+                                                     rest)))))))
+                                    ((alias-form)
+                                     (process-exports
+                                       fexports
+                                       (lambda ()
+                                         (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                           (when (indirect-label? label)
+                                             (unless (symbol? (get-indirect-label label))
+                                               (syntax-error (module-binding-id b) "unexported target of alias")))
+                                           rest))))
+                                    (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))
+                            (loop bs))))))))))))
+
+(define id-set-diff
+  (lambda (exports defs)
+    (cond
+      ((null? exports) '())
+      ((bound-id-member? (car exports) defs) (id-set-diff (cdr exports) defs))
+      (else (cons (car exports) (id-set-diff (cdr exports) defs))))))
+
+(define check-module-exports
+  ; After processing the definitions of a module this is called to verify that the
+  ; module has defined or imported each exported identifier.  Because ids in fexports are
+  ; wrapped with the given ribcage, they will contain substitutions for anything defined
+  ; or imported here.  These subsitutions can be used by do-import! and do-import-top! to
+  ; provide access to reexported bindings, for example.
+  (lambda (source-exp fexports ids)
+    (define defined?
+      (lambda (e ids)
+        (ormap (lambda (x)
+                 (if (import-interface? x)
+                     (let ((x.iface (import-interface-interface x))
+                           (x.new-marks (import-interface-new-marks x)))
+                       (cond
+                         ((interface-token x.iface) =>
+                          (lambda (token)
+                            (lookup-import-binding-name (id-sym-name e) (id-marks e) token x.new-marks)))
+                         (else
+                          (let ((v (interface-exports x.iface)))
+                            (let lp ((i (fx- (vector-length v) 1)))
+                              (and (fx>= i 0)
+                                   (or (let ((id (vector-ref v i)))
+                                         (help-bound-id=?
+                                           (id-sym-name id)
+                                           (join-marks x.new-marks (id-marks id))
+                                           (id-sym-name e) (id-marks e)))
+                                       (lp (fx- i 1)))))))))
+                     (bound-id=? e x)))
+               ids)))
+    (let loop ((fexports fexports) (missing '()))
+      (if (null? fexports)
+          (unless (null? missing)
+            (syntax-error (car missing)
+              (if (fx= (length missing) 1)
+                  "missing definition for export"
+                  "missing definition for multiple exports, including")))
+          (let ((e (car fexports)) (fexports (cdr fexports)))
+            (if (defined? e ids)
+                (loop fexports missing)
+                (loop fexports (cons e missing))))))))
+
+(define check-defined-ids
+  (lambda (source-exp ls)
+    (define vfold
+      (lambda (v p cls)
+        (let ((len (vector-length v)))
+          (let lp ((i 0) (cls cls))
+            (if (fx= i len)
+                cls
+                (lp (fx+ i 1) (p (vector-ref v i) cls)))))))
+    (define conflicts
+      (lambda (x y cls)
+        (if (import-interface? x)
+            (let ((x.iface (import-interface-interface x))
+                  (x.new-marks (import-interface-new-marks x)))
+              (if (import-interface? y)
+                  (let ((y.iface (import-interface-interface y))
+                        (y.new-marks (import-interface-new-marks y)))
+                    (let ((xe (interface-exports x.iface)) (ye (interface-exports y.iface)))
+                      (if (fx> (vector-length xe) (vector-length ye))
+                          (vfold ye
+                            (lambda (id cls)
+                              (id-iface-conflicts id y.new-marks x.iface x.new-marks cls)) cls)
+                          (vfold xe
+                            (lambda (id cls)
+                              (id-iface-conflicts id x.new-marks y.iface y.new-marks cls)) cls))))
+                  (id-iface-conflicts y '() x.iface x.new-marks cls)))
+            (if (import-interface? y)
+                (let ((y.iface (import-interface-interface y))
+                      (y.new-marks (import-interface-new-marks y)))
+                  (id-iface-conflicts x '() y.iface y.new-marks cls))
+                (if (bound-id=? x y) (cons x cls) cls)))))
+     (define id-iface-conflicts
+       (lambda (id id.new-marks iface iface.new-marks cls)
+         (let ((id.sym (id-sym-name id))
+               (id.marks (join-marks id.new-marks (id-marks id))))
+           (cond
+             ((interface-token iface) =>
+              (lambda (token)
+                (if (lookup-import-binding-name id.sym id.marks token iface.new-marks)
+                    (cons id cls)
+                    cls)))
+             (else
+              (vfold (interface-exports iface)
+                     (lambda (*id cls)
+                       (let ((*id.sym (id-sym-name *id))
+                             (*id.marks (join-marks iface.new-marks (id-marks *id))))
+                         (if (help-bound-id=? *id.sym *id.marks id.sym id.marks)
+                             (cons *id cls)
+                             cls)))
+                     cls))))))
+     (unless (null? ls)
+       (let lp ((x (car ls)) (ls (cdr ls)) (cls '()))
+         (if (null? ls)
+             (unless (null? cls)
+               (let ((cls (syntax-object->datum cls)))
+                 (syntax-error source-exp "duplicate definition for "
+                  (symbol->string (car cls))
+                   " in")))
+             (let lp2 ((ls2 ls) (cls cls))
+               (if (null? ls2)
+                   (lp (car ls) (cdr ls) cls)
+                   (lp2 (cdr ls2) (conflicts x (car ls2) cls)))))))))
+
+(define chi-external
+  (lambda (ribcage source-exp body r mr ctem exports fexports meta-residualize!)
+    (define return
+      (lambda (r mr bindings ids inits)
+        (check-defined-ids source-exp ids)
+        (check-module-exports source-exp fexports ids)
+        (values r mr bindings inits)))
+    (define get-implicit-exports
+      (lambda (id)
+        (let f ((exports exports))
+          (if (null? exports)
+              '()
+              (if (and (pair? (car exports)) (bound-id=? id (caar exports)))
+                  (flatten-exports (cdar exports))
+                  (f (cdr exports)))))))
+    (define update-imp-exports
+      (lambda (bindings exports)
+        (let ((exports (map (lambda (x) (if (pair? x) (car x) x)) exports)))
+          (map (lambda (b)
+                 (let ((id (module-binding-id b)))
+                   (if (not (bound-id-member? id exports))
+                       b
+                       (create-module-binding
+                         (module-binding-type b)
+                         id
+                         (module-binding-label b)
+                         (append (get-implicit-exports id) (module-binding-imps b))
+                         (module-binding-val b)))))
+               bindings))))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (bindings '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr bindings ids inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (sym (generate-id (id-sym-name id)))
+                          (imps (get-implicit-exports id)))
+                     (extend-ribcage! ribcage id label)
+                     (cond
+                       (meta?
+                        (let* ((sym (generate-id (id-sym-name id)))
+                               (b (make-binding 'meta-variable sym)))
+                         ; add meta bindings only to meta environment
+                          (let ((mr (extend-env (get-indirect-label label) b mr)))
+                            (let ((exp (chi rhs mr mr w #t)))
+                              (define-top-level-value-hook sym (top-level-eval-hook exp))
+                              (meta-residualize!
+                                (ct-eval/residualize3 ctem
+                                  void
+                                  (lambda () (build-global-definition no-source sym exp))))
+                              (parse (cdr body) r mr
+                                (cons id ids)
+                                (cons (create-module-binding 'ctdefine-form id label imps b) bindings)
+                                inits
+                                #f)))))
+                       (else
+                        (parse (cdr body) r mr
+                          (cons id ids)
+                          (cons (create-module-binding type id label
+                                  imps (make-frob (wrap rhs w) meta?))
+                                bindings)
+                          inits
+                          #f))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (imps (get-implicit-exports id))
+                          (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((l (get-indirect-label label)) (b (defer-or-eval-transformer top-level-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env l b r)
+                         (extend-env l b mr)
+                         (cons id ids)
+                         (cons (create-module-binding type id label imps (cons b exp))
+                               bindings)
+                         inits
+                         #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id *exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *bindings *inits)
+                                   (chi-external *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr ctem *exports (flatten-exports *exports) meta-residualize!)))
+                       (let ((iface (make-unresolved-interface id *exports))
+                             (bindings (append *bindings bindings))
+                             (inits (append inits *inits))
+                             (label (gen-indirect-label))
+                             (imps (get-implicit-exports id)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((l (get-indirect-label label)) (b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env l b r)
+                             (extend-env l b mr)
+                             (cons id ids)
+                             (cons (create-module-binding type id label imps *exports) bindings)
+                             inits
+                             #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr
+                             (cons import-iface ids)
+                             (update-imp-exports bindings (vector->list (interface-exports iface)))
+                             inits
+                             #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+               ((alias-form)
+                (let-values (((new-id old-id) (parse-alias e w ae)))
+                  (let* ((new-id (wrap new-id w))
+                         (label (id-var-name-loc old-id w))
+                         (imps (get-implicit-exports new-id)))
+                    (extend-ribcage! ribcage new-id label)
+                    (parse (cdr body) r mr
+                      (cons new-id ids)
+                      (cons (create-module-binding type new-id label imps #f)
+                            bindings)
+                      inits
+                      #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids bindings inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                    (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                               (let f ((forms forms))
+                                 (if (null? forms)
+                                     (cdr body)
+                                     (cons (make-frob (wrap (car forms) w) meta?)
+                                           (f (cdr forms)))))
+                               (cdr body))
+                      r mr ids bindings inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids bindings inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids bindings inits #f)))
+                (else ; found an init expression
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr bindings ids (append inits body))
+                       (begin
+                        ; expand and eval meta inits for effect only
+                         (let ((x (chi-meta-frob (car body) mr)))
+                           (top-level-eval-hook x)
+                           (meta-residualize! (ct-eval/residualize3 ctem void (lambda () x))))
+                         (f (cdr body)))))))))))))
+
+(define vmap
+  (lambda (fn v)
+    (do ((i (fx- (vector-length v) 1) (fx- i 1))
+         (ls '() (cons (fn (vector-ref v i)) ls)))
+        ((fx< i 0) ls))))
+
+(define vfor-each
+  (lambda (fn v)
+    (let ((len (vector-length v)))
+      (do ((i 0 (fx+ i 1)))
+          ((fx= i len))
+        (fn (vector-ref v i))))))
+
+(define do-top-import
+  (lambda (import-only? top-ribcage mid token)
+   ; silently treat import-only like regular import at top level
+    (build-cte-install mid
+      (build-data no-source
+        (make-binding 'do-import token))
+      (top-ribcage-key top-ribcage))))
+
+(define update-mode-set
+  (let ((table
+         '((L (load . L) (compile . C) (visit . V) (revisit . R) (eval . -))
+           (C (load . -) (compile . -) (visit . -) (revisit . -) (eval . C))
+           (V (load . V) (compile . C) (visit . V) (revisit . -) (eval . -))
+           (R (load . R) (compile . C) (visit . -) (revisit . R) (eval . -))
+           (E (load . -) (compile . -) (visit . -) (revisit . -) (eval . E)))))
+    (lambda (when-list mode-set)
+      (define remq
+        (lambda (x ls)
+          (if (null? ls)
+              '()
+              (if (eq? (car ls) x)
+                  (remq x (cdr ls))
+                  (cons (car ls) (remq x (cdr ls)))))))
+      (remq '-
+        (apply append
+          (map (lambda (m)
+                 (let ((row (cdr (assq m table))))
+                   (map (lambda (s) (cdr (assq s row)))
+                        when-list)))
+               mode-set))))))
+
+(define initial-mode-set
+  (lambda (when-list compiling-a-file)
+    (apply append
+      (map (lambda (s)
+             (if compiling-a-file
+                 (case s
+                   ((compile) '(C))
+                   ((load) '(L))
+                   ((visit) '(V))
+                   ((revisit) '(R))
+                   (else '()))
+                 (case s
+                   ((eval) '(E))
+                   (else '()))))
+           when-list))))
+
+(define rt-eval/residualize
+  (lambda (rtem thunk)
+    (if (memq 'E rtem)
+        (thunk)
+        (let ((thunk (if (memq 'C rtem)
+                         (let ((x (thunk)))
+                           (top-level-eval-hook x)
+                           (lambda () x))
+                         thunk)))
+          (if (memq 'V rtem)
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (thunk) ; visit-revisit
+                  (build-visit-only (thunk)))
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (build-revisit-only (thunk))
+                  (chi-void)))))))
+
+(define ct-eval/residualize2
+  (lambda (ctem thunk)
+    (let ((t #f))
+      (ct-eval/residualize3 ctem
+        (lambda ()
+          (unless t (set! t (thunk)))
+          (top-level-eval-hook t))
+        (lambda () (or t (thunk)))))))
+
+(define ct-eval/residualize3
+  (lambda (ctem eval-thunk residualize-thunk)
+    (if (memq 'E ctem)
+        (begin (eval-thunk) (chi-void))
+        (begin
+          (when (memq 'C ctem) (eval-thunk))
+          (if (memq 'R ctem)
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (residualize-thunk) ; visit-revisit
+                  (build-revisit-only (residualize-thunk)))
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (build-visit-only (residualize-thunk))
+                  (chi-void)))))))
+
+(define chi-frobs
+  (lambda (frob* r mr m?)
+    (map (lambda (x) (chi (frob-e x) r mr empty-wrap m?)) frob*)))
+
+(define chi-meta-frob
+  (lambda (x mr)
+    (chi (frob-e x) mr mr empty-wrap #t)))
+
+(define chi-sequence
+  (lambda (body r mr w ae m?)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi (car body) r mr w m?)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi
+  (lambda (e r mr w m?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source #f)))
+      (chi-expr type value e r mr w ae m?))))
+
+(define chi-expr
+  (lambda (type value e r mr w ae m?)
+    (case type
+      ((lexical)
+       (build-lexical-reference 'value ae value))
+      ((core) (value e r mr w ae m?))
+      ((lexical-call)
+       (chi-application
+         (build-lexical-reference 'fun
+           (let ((x (car e)))
+             (if (syntax-object? x) (syntax-object-expression x) x))
+           value)
+         e r mr w ae m?))
+      ((constant) (build-data ae (strip (source-wrap e w ae) empty-wrap)))
+      ((global) (build-global-reference ae value))
+      ((meta-variable)
+       (if m?
+           (build-global-reference ae value)
+           (displaced-lexical-error (source-wrap e w ae))))
+      ((call) (chi-application (chi (car e) r mr w m?) e r mr w ae m?))
+      ((begin-form) (chi-sequence (parse-begin e w ae #f) r mr w ae m?))
+      ((local-syntax-form)
+       (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+         (chi-sequence forms r mr w ae m?)))
+      ((eval-when-form)
+       (let-values (((when-list forms) (parse-eval-when e w ae)))
+         (if (memq 'eval when-list) ; mode set is implicitly (E)
+             (chi-sequence forms r mr w ae m?)
+             (chi-void))))
+      ((meta-form)
+       (syntax-error (source-wrap e w ae) "invalid context for meta definition"))
+      ((define-form)
+       (parse-define e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((define-syntax-form)
+       (parse-define-syntax e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      (($module-form)
+       (let-values (((orig id exports forms) (parse-module e w ae w)))
+         (syntax-error orig "invalid context for definition")))
+      (($import-form)
+       (let-values (((orig only? mid) (parse-import e w ae)))
+         (syntax-error orig "invalid context for definition")))
+      ((alias-form)
+       (parse-alias e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((syntax)
+       (syntax-error (source-wrap e w ae)
+         "reference to pattern variable outside syntax form"))
+      ((displaced-lexical) (displaced-lexical-error (source-wrap e w ae)))
+      (else (syntax-error (source-wrap e w ae))))))
+
+(define chi-application
+  (lambda (x e r mr w ae m?)
+    (syntax-case e ()
+      ((e0 e1 ...)
+       (build-application ae x
+         (map (lambda (e) (chi e r mr w m?)) (syntax (e1 ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-set!
+  (lambda (e r w ae rib)
+    (syntax-case e ()
+      ((_ id val)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             ((macro!)
+              (let ((id (wrap (syntax id) w)) (val (wrap (syntax val) w)))
+                (syntax-type (chi-macro (binding-value b)
+                               `(,(syntax set!) ,id ,val)
+                               r empty-wrap #f rib) r empty-wrap #f rib)))
+             (else
+              (values 'core
+                (lambda (e r mr w ae m?)
+                 ; repeat lookup in case we were first expression (init) in
+                 ; module or lambda body.  we repeat id-var-name as well,
+                 ; although this is only necessary if we allow inits to
+                 ; preced definitions
+                  (let ((val (chi (syntax val) r mr w m?))
+                        (n (id-var-name (syntax id) w)))
+                    (let ((b (lookup n r)))
+                      (case (binding-type b)
+                        ((lexical) (build-lexical-assignment ae (binding-value b) val))
+                        ((global)
+                         (let ((sym (binding-value b)))
+                           (when (read-only-binding? n)
+                             (syntax-error (source-wrap e w ae)
+                               "invalid assignment to read-only variable"))
+                           (build-global-assignment ae sym val)))
+                        ((meta-variable)
+                         (if m?
+                             (build-global-assignment ae (binding-value b) val)
+                             (displaced-lexical-error (wrap (syntax id) w))))
+                        ((displaced-lexical)
+                         (displaced-lexical-error (wrap (syntax id) w)))
+                        (else (syntax-error (source-wrap e w ae)))))))
+                e w ae))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+
+
+(define chi-macro
+  (lambda (p e r w ae rib)
+    (define rebuild-macro-output
+      (lambda (x m)
+        (cond ((pair? x)
+               (cons (rebuild-macro-output (car x) m)
+                     (rebuild-macro-output (cdr x) m)))
+              ((syntax-object? x)
+               (let ((w (syntax-object-wrap x)))
+                 (let ((ms (wrap-marks w)) (s (wrap-subst w)))
+                   (make-syntax-object (syntax-object-expression x)
+                     (if (and (pair? ms) (eq? (car ms) the-anti-mark))
+                         (make-wrap (cdr ms) (cdr s))
+                         (make-wrap (cons m ms)
+                           (if rib
+                               (cons rib (cons 'shift s))
+                               (cons 'shift s))))))))
+              ((vector? x)
+               (let* ((n (vector-length x)) (v (make-vector n)))
+                 (do ((i 0 (fx+ i 1)))
+                     ((fx= i n) v)
+                     (vector-set! v i
+                       (rebuild-macro-output (vector-ref x i) m)))))
+              ((symbol? x)
+               (syntax-error (source-wrap e w ae)
+                 "encountered raw symbol "
+                (symbol->string x)
+                 " in output of macro"))
+              (else x))))
+    (rebuild-macro-output
+      (let ((out (p (source-wrap e (anti-mark w) ae))))
+        (if (procedure? out)
+            (out (lambda (id)
+                   (unless (identifier? id)
+                     (syntax-error id
+                       "environment argument is not an identifier"))
+                   (lookup (id-var-name id empty-wrap) r)))
+            out))
+      (new-mark))))
+
+(define chi-body
+  (lambda (body outer-form r mr w m?)
+    (let* ((ribcage (make-empty-ribcage))
+           (w (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))
+           (body (map (lambda (x) (make-frob (wrap x w) #f)) body)))
+      (let-values (((r mr exprs ids vars vals inits)
+                    (chi-internal ribcage outer-form body r mr m?)))
+        (when (null? exprs) (syntax-error outer-form "no expressions in body"))
+        (build-body no-source
+          (reverse vars) (chi-frobs (reverse vals) r mr m?)
+          (build-sequence no-source
+            (chi-frobs (append inits exprs) r mr m?)))))))
+
+(define chi-internal
+  ;; In processing the forms of the body, we create a new, empty wrap.
+  ;; This wrap is augmented (destructively) each time we discover that
+  ;; the next form is a definition.  This is done:
+  ;;
+  ;;   (1) to allow the first nondefinition form to be a call to
+  ;;       one of the defined ids even if the id previously denoted a
+  ;;       definition keyword or keyword for a macro expanding into a
+  ;;       definition;
+  ;;   (2) to prevent subsequent definition forms (but unfortunately
+  ;;       not earlier ones) and the first nondefinition form from
+  ;;       confusing one of the bound identifiers for an auxiliary
+  ;;       keyword; and
+  ;;   (3) so that we do not need to restart the expansion of the
+  ;;       first nondefinition form, which is problematic anyway
+  ;;       since it might be the first element of a begin that we
+  ;;       have just spliced into the body (meaning if we restarted,
+  ;;       we'd really need to restart with the begin or the macro
+  ;;       call that expanded into the begin, and we'd have to give
+  ;;       up allowing (begin <defn>+ <expr>+), which is itself
+  ;;       problematic since we don't know if a begin contains only
+  ;;       definitions until we've expanded it).
+  ;;
+  ;; Subforms of a begin, let-syntax, or letrec-syntax are spliced
+  ;; into the body.
+  ;;
+  ;; outer-form is fully wrapped w/source
+  (lambda (ribcage source-exp body r mr m?)
+    (define return
+      (lambda (r mr exprs ids vars vals inits)
+        (check-defined-ids source-exp ids)
+        (values r mr exprs ids vars vals inits)))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (vars '()) (vals '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr body ids vars vals inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let ((id (wrap id w)) (label (gen-label)))
+                     (cond
+                       (meta?
+                        (let ((sym (generate-id (id-sym-name id))))
+                          (extend-ribcage! ribcage id label)
+                         ; add meta bindings only to meta environment
+                         ; so visible only to next higher level and beyond
+                          (let ((mr (extend-env label (make-binding 'meta-variable sym) mr)))
+                            (define-top-level-value-hook sym
+                              (top-level-eval-hook (chi rhs mr mr w #t)))
+                            (parse (cdr body) r mr (cons id ids) vars vals inits #f))))
+                       (else
+                        (let ((var (gen-var id)))
+                          (extend-ribcage! ribcage id label)
+                         ; add lexical bindings only to run-time environment
+                          (parse (cdr body)
+                            (extend-env label (make-binding 'lexical var) r)
+                            mr
+                            (cons id ids)
+                            (cons var vars)
+                            (cons (make-frob (wrap rhs w) meta?) vals)
+                            inits
+                            #f)))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let ((id (wrap id w))
+                         (label (gen-label))
+                         (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((b (defer-or-eval-transformer local-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env label b r) (extend-env label b mr)
+                         (cons id ids) vars vals inits #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *body *ids *vars *vals *inits)
+                                   (chi-internal *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr m?)))
+                      ; valid bound ids checked already by chi-internal
+                       (check-module-exports source-exp (flatten-exports exports) *ids)
+                       (let ((iface (make-resolved-interface id exports #f))
+                             (vars (append *vars vars))
+                             (vals (append *vals vals))
+                             (inits (append inits *inits *body))
+                             (label (gen-label)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env label b r) (extend-env label b mr)
+                             (cons id ids) vars vals inits #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr (cons import-iface ids) vars vals inits #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+                ((alias-form)
+                 (let-values (((new-id old-id) (parse-alias e w ae)))
+                   (let ((new-id (wrap new-id w)))
+                     (extend-ribcage! ribcage new-id (id-var-name-loc old-id w))
+                     (parse (cdr body) r mr
+                       (cons new-id ids)
+                       vars
+                       vals
+                       inits
+                       #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids vars vals inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                   (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                              (let f ((forms forms))
+                                (if (null? forms)
+                                    (cdr body)
+                                    (cons (make-frob (wrap (car forms) w) meta?)
+                                          (f (cdr forms)))))
+                              (cdr body))
+                     r mr ids vars vals inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids vars vals inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids vars vals inits #f)))
+                (else ; found a non-definition
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr body ids vars vals inits)
+                       (begin
+                        ; expand meta inits for effect only
+                         (top-level-eval-hook (chi-meta-frob (car body) mr))
+                         (f (cdr body)))))))))))))
+
+(define import-mark-delta
+ ; returns list of marks layered on top of module id beyond those
+ ; cached in the interface
+  (lambda (mid iface)
+    (diff-marks (id-marks mid) (interface-marks iface))))
+
+(define lookup-import-label
+  (lambda (id)
+    (let ((label (id-var-name-loc id empty-wrap)))
+      (unless label
+        (syntax-error id "exported identifier not visible"))
+      label)))
+  
+(define do-import!
+  (lambda (import-iface ribcage)
+    (let ((ie (interface-exports (import-interface-interface import-iface))))
+      (if (fx<= (vector-length ie) 20)
+          (let ((new-marks (import-interface-new-marks import-iface)))
+            (vfor-each
+              (lambda (id)
+                (import-extend-ribcage! ribcage new-marks id
+                  (lookup-import-label id)))
+              ie))
+          (extend-ribcage-subst! ribcage import-iface)))))
+
+(define parse-module
+  (lambda (e w ae *w)
+    (define listify
+      (lambda (exports)
+        (if (null? exports)
+            '()
+            (cons (syntax-case (car exports) ()
+                    ((ex ...) (listify (syntax (ex ...))))
+                    (x (if (id? (syntax x))
+                           (wrap (syntax x) *w)
+                           (syntax-error (source-wrap e w ae)
+                             "invalid exports list in"))))
+                  (listify (cdr exports))))))
+    (syntax-case e ()
+      ((_ orig mid (ex ...) form ...)
+       (id? (syntax mid))
+      ; id receives old wrap so it won't be confused with id of same name
+      ; defined within the module
+       (values (syntax orig) (wrap (syntax mid) w) (listify (syntax (ex ...))) (map (lambda (x) (wrap x *w)) (syntax (form ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-import
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ orig #t mid)
+       (id? (syntax mid))
+       (values (syntax orig) #t (wrap (syntax mid) w)))
+      ((_ orig #f mid)
+       (id? (syntax mid))
+       (values (syntax orig) #f (wrap (syntax mid) w)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      ((_ (name . args) e1 e2 ...)
+       (and (id? (syntax name))
+            (valid-bound-ids? (lambda-var-list (syntax args))))
+       (values (wrap (syntax name) w)
+               (cons (syntax lambda) (wrap (syntax (args e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name)
+       (id? (syntax name))
+       (values (wrap (syntax name) w) (syntax (void)) empty-wrap))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define-syntax
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (name id) e1 e2 ...)
+       (and (id? (syntax name)) (id? (syntax id)))
+       (values (wrap (syntax name) w)
+               `(,(syntax lambda) ,(wrap (syntax (id)) w)
+                   ,@(wrap (syntax (e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-meta
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ . form) (syntax form))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-eval-when
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (x ...) e1 e2 ...)
+       (values (chi-when-list (syntax (x ...)) w) (syntax (e1 e2 ...))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-alias
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ new-id old-id)
+       (and (id? (syntax new-id)) (id? (syntax old-id)))
+       (values (syntax new-id) (syntax old-id)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-begin
+  (lambda (e w ae empty-okay?)
+    (syntax-case e ()
+      ((_) empty-okay? '())
+      ((_ e1 e2 ...) (syntax (e1 e2 ...)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-lambda-clause
+  (lambda (e c r mr w m?)
+    (syntax-case c ()
+      (((id ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (values
+                 new-vars
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap ids labels w)
+                           m?))))))
+      ((ids e1 e2 ...)
+       (let ((old-ids (lambda-var-list (syntax ids))))
+         (if (not (valid-bound-ids? old-ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels old-ids))
+                   (new-vars (map gen-var old-ids)))
+               (values
+                 (let f ((ls1 (cdr new-vars)) (ls2 (car new-vars)))
+                   (if (null? ls1)
+                       ls2
+                       (f (cdr ls1) (cons (car ls1) ls2))))
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap old-ids labels w)
+                           m?))))))
+      (_ (syntax-error e)))))
+
+(define chi-local-syntax
+  (lambda (rec? e r mr w ae)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae)
+               "keyword")
+             (let ((labels (gen-labels ids)))
+               (let ((new-w (make-binding-wrap ids labels w)))
+                 (let ((b* (let ((w (if rec? new-w w)))
+                             (map (lambda (x)
+                                    (defer-or-eval-transformer
+                                      local-eval-hook
+                                      (chi x mr mr w #t)))
+                                  (syntax (val ...))))))
+                   (values
+                     (syntax (e1 e2 ...))
+                     (extend-env* labels b* r)
+                     (extend-env* labels b* mr)
+                     new-w
+                     ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-void
+  (lambda ()
+    (build-application no-source (build-primref no-source 'void) '())))
+
+(define ellipsis?
+  (lambda (x)
+    (and (nonsymbol-id? x)
+         (literal-id=? x (syntax (... ...))))))
+
+;;; data
+
+;;; strips all annotations from potentially circular reader output.
+
+(define strip-annotation
+  (lambda (x)
+    (cond
+      ((pair? x)
+       (cons (strip-annotation (car x))
+             (strip-annotation (cdr x))))
+      ((annotation? x) (annotation-stripped x))
+      (else x))))
+
+;;; strips syntax-objects down to top-wrap; if top-wrap is layered directly
+;;; on an annotation, strips the annotation as well.
+;;; since only the head of a list is annotated by the reader, not each pair
+;;; in the spine, we also check for pairs whose cars are annotated in case
+;;; we've been passed the cdr of an annotated list
+
+(define strip*
+  (lambda (x w fn)
+    (if (top-marked? w)
+        (fn x)
+        (let f ((x x))
+          (cond
+            ((syntax-object? x)
+             (strip* (syntax-object-expression x) (syntax-object-wrap x) fn))
+            ((pair? x)
+             (let ((a (f (car x))) (d (f (cdr x))))
+               (if (and (eq? a (car x)) (eq? d (cdr x)))
+                   x
+                   (cons a d))))
+            ((vector? x)
+             (let ((old (vector->list x)))
+                (let ((new (map f old)))
+                   (if (andmap eq? old new) x (list->vector new)))))
+            (else x))))))
+
+(define strip
+  (lambda (x w)
+    (strip* x w
+      (lambda (x)
+        (if (or (annotation? x) (and (pair? x) (annotation? (car x))))
+            (strip-annotation x)
+            x)))))
+
+;;; lexical variables
+
+(define gen-var
+  (lambda (id)
+    (let ((id (if (syntax-object? id) (syntax-object-expression id) id)))
+      (if (annotation? id)
+          (build-lexical-var id (annotation-expression id))
+          (build-lexical-var id id)))))
+
+(define lambda-var-list
+  (lambda (vars)
+    (let lvl ((vars vars) (ls '()) (w empty-wrap))
+       (cond
+         ((pair? vars) (lvl (cdr vars) (cons (wrap (car vars) w) ls) w))
+         ((id? vars) (cons (wrap vars w) ls))
+         ((null? vars) ls)
+         ((syntax-object? vars)
+          (lvl (syntax-object-expression vars)
+               ls
+               (join-wraps w (syntax-object-wrap vars))))
+         ((annotation? vars)
+          (lvl (annotation-expression vars) ls w))
+       ; include anything else to be caught by subsequent error
+       ; checking
+         (else (cons vars ls))))))
+
+
+; must precede global-extends
+
+(primitive-set! '$sc-put-cte
+  (lambda (id b top-token)
+     (define sc-put-module
+       (lambda (exports token new-marks)
+         (vfor-each
+           (lambda (id) (store-import-binding id token new-marks))
+           exports)))
+     (define (put-cte id binding token)
+       (let ((sym (if (symbol? id) id (id-var-name id empty-wrap))))
+        (store-import-binding id token '())
+         (put-global-definition-hook sym
+          ; global binding is assumed; if global pass #f to remove existing binding, if any
+           (if (and (eq? (binding-type binding) 'global)
+                    (eq? (binding-value binding) sym))
+               #f
+               binding))))
+     (let ((binding (make-transformer-binding b)))
+       (case (binding-type binding)
+         (($module)
+          (let ((iface (binding-value binding)))
+            (sc-put-module (interface-exports iface) (interface-token iface) '()))
+          (put-cte id binding top-token))
+         ((do-alias) (store-import-binding id top-token '()))
+         ((do-import)
+          ; fake binding: id is module id binding-value is token
+          (let ((token (binding-value b)))
+             (let ((b (lookup (id-var-name id empty-wrap) null-env)))
+               (case (binding-type b)
+                 (($module)
+                  (let* ((iface (binding-value b))
+                         (exports (interface-exports iface)))
+                    (unless (eq? (interface-token iface) token)
+                      (syntax-error id "import mismatch for module"))
+                    (sc-put-module (interface-exports iface) top-token
+                      (import-mark-delta id iface))))
+                 (else (syntax-error id "unknown module"))))))
+         (else (put-cte id binding top-token))))
+     ))
+
+
+;;; core transformers
+
+(global-extend 'local-syntax 'letrec-syntax #t)
+(global-extend 'local-syntax 'let-syntax #f)
+
+
+(global-extend 'core 'fluid-let-syntax
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((var val) ...) e1 e2 ...)
+       (valid-bound-ids? (syntax (var ...)))
+       (let ((names (map (lambda (x) (id-var-name x w)) (syntax (var ...)))))
+         (for-each
+           (lambda (id n)
+             (case (binding-type (lookup n r))
+               ((displaced-lexical) (displaced-lexical-error (wrap id w)))))
+           (syntax (var ...))
+           names)
+         (let ((b* (map (lambda (x)
+                          (defer-or-eval-transformer
+                            local-eval-hook
+                            (chi x mr mr w #t)))
+                        (syntax (val ...)))))
+           (chi-body
+             (syntax (e1 e2 ...))
+             (source-wrap e w ae)
+             (extend-env* names b* r)
+             (extend-env* names b* mr)
+             w
+             m?))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'quote
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ e) (build-data ae (strip (syntax e) w)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core '|#primitive|
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ e) (id? #'e)
+          (build-primref ae (strip (syntax e) w)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'syntax
+  (let ()
+    (define gen-syntax
+      (lambda (src e r maps ellipsis? vec?)
+        (if (id? e)
+            (let ((label (id-var-name e empty-wrap)))
+              (let ((b (lookup label r)))
+                (if (eq? (binding-type b) 'syntax)
+                    (let-values (((var maps)
+                                  (let ((var.lev (binding-value b)))
+                                    (gen-ref src (car var.lev) (cdr var.lev) maps))))
+                      (values `(ref ,var) maps))
+                    (if (ellipsis? e)
+                        (syntax-error src "misplaced ellipsis in syntax form")
+                        (values `(quote ,e) maps)))))
+            (syntax-case e ()
+              ((dots e)
+               (ellipsis? (syntax dots))
+               (if vec?
+                   (syntax-error src "misplaced ellipsis in syntax template")
+                   (gen-syntax src (syntax e) r maps (lambda (x) #f) #f)))
+              ((x dots . y)
+               ; this could be about a dozen lines of code, except that we
+               ; choose to handle (syntax (x ... ...)) forms
+               (ellipsis? (syntax dots))
+               (let f ((y (syntax y))
+                       (k (lambda (maps)
+                            (let-values (((x maps)
+                                          (gen-syntax src (syntax x) r
+                                            (cons '() maps) ellipsis? #f)))
+                              (if (null? (car maps))
+                                  (syntax-error src
+                                    "extra ellipsis in syntax form")
+                                  (values (gen-map x (car maps))
+                                          (cdr maps)))))))
+                 (syntax-case y ()
+                   ((dots . y)
+                    (ellipsis? (syntax dots))
+                    (f (syntax y)
+                       (lambda (maps)
+                         (let-values (((x maps) (k (cons '() maps))))
+                           (if (null? (car maps))
+                               (syntax-error src
+                                 "extra ellipsis in syntax form")
+                               (values (gen-mappend x (car maps))
+                                       (cdr maps)))))))
+                   (_ (let-values (((y maps) (gen-syntax src y r maps ellipsis? vec?)))
+                        (let-values (((x maps) (k maps)))
+                          (values (gen-append x y) maps)))))))
+              ((x . y)
+               (let-values (((xnew maps) (gen-syntax src (syntax x) r maps ellipsis? #f)))
+                 (let-values (((ynew maps) (gen-syntax src (syntax y) r maps ellipsis? vec?)))
+                   (values (gen-cons e (syntax x) (syntax y) xnew ynew)
+                           maps))))
+              (#(x1 x2 ...)
+               (let ((ls (syntax (x1 x2 ...))))
+                 (let-values (((lsnew maps) (gen-syntax src ls r maps ellipsis? #t)))
+                   (values (gen-vector e ls lsnew) maps))))
+              (_ (values `(quote ,e) maps))))))
+
+    (define gen-ref
+      (lambda (src var level maps)
+        (if (fx= level 0)
+            (values var maps)
+            (if (null? maps)
+                (syntax-error src "missing ellipsis in syntax form")
+                (let-values (((outer-var outer-maps) (gen-ref src var (fx- level 1) (cdr maps))))
+                  (let ((b (assq outer-var (car maps))))
+                    (if b
+                        (values (cdr b) maps)
+                        (let ((inner-var (gen-var 'tmp)))
+                          (values inner-var
+                                  (cons (cons (cons outer-var inner-var)
+                                              (car maps))
+                                        outer-maps))))))))))
+
+    (define gen-append
+      (lambda (x y)
+        (if (equal? y '(quote ()))
+            x
+            `(append ,x ,y))))
+
+    (define gen-mappend
+      (lambda (e map-env)
+        `(apply (primitive append) ,(gen-map e map-env))))
+
+    (define gen-map
+      (lambda (e map-env)
+        (let ((formals (map cdr map-env))
+              (actuals (map (lambda (x) `(ref ,(car x))) map-env)))
+          (cond
+            ((eq? (car e) 'ref)
+             ; identity map equivalence:
+             ; (map (lambda (x) x) y) == y
+             (car actuals))
+            ((andmap
+                (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) formals)))
+                (cdr e))
+             ; eta map equivalence:
+             ; (map (lambda (x ...) (f x ...)) y ...) == (map f y ...)
+             `(map (primitive ,(car e))
+                   ,@(map (let ((r (map cons formals actuals)))
+                            (lambda (x) (cdr (assq (cadr x) r))))
+                          (cdr e))))
+            (else `(map (case-lambda [,formals ,e]) ,@actuals))))))
+
+   ; 12/12/00: semantic change: we now return original syntax object (e)
+   ; if no pattern variables were found within, to avoid dropping
+   ; source annotations prematurely.  the "syntax returns lists" for
+   ; lists in its input guarantee counts only for substructure that
+   ; contains pattern variables
+    (define gen-cons
+      (lambda (e x y xnew ynew)
+        (case (car ynew)
+          ((quote)
+           (if (eq? (car xnew) 'quote)
+               (let ((xnew (cadr xnew)) (ynew (cadr ynew)))
+                 (if (and (eq? xnew x) (eq? ynew y))
+                     `',e
+                     `'(,xnew . ,ynew)))
+               (if (eq? (cadr ynew) '()) `(list ,xnew) `(cons ,xnew ,ynew))))
+          ((list) `(list ,xnew ,@(cdr ynew)))
+          (else `(cons ,xnew ,ynew)))))
+
+    (define gen-vector
+      (lambda (e ls lsnew)
+        (cond
+          ((eq? (car lsnew) 'quote)
+           (if (eq? (cadr lsnew) ls)
+               `',e
+               `(quote #(,@(cadr lsnew)))))
+          ((eq? (car lsnew) 'list) `(vector ,@(cdr lsnew)))
+          (else `(list->vector ,lsnew)))))
+
+
+    (define regen
+      (lambda (x)
+        (case (car x)
+          ((ref) (build-lexical-reference 'value no-source (cadr x)))
+          ((primitive) (build-primref no-source (cadr x)))
+          ((quote) (build-data no-source (cadr x)))
+          ((lambda) 
+           (build-lambda no-source (cadr x) (regen (caddr x))))
+          ((case-lambda)
+           (let ([d (cdr x)])
+             (build-case-lambda no-source
+              (map car d)
+              (map (lambda (x) (regen (cadr x))) d))))
+          ((map) (let ((ls (map regen (cdr x))))
+                   (build-application no-source
+                     (if (fx= (length ls) 2)
+                         (build-primref no-source 'map)
+                        ; really need to do our own checking here
+                         (build-primref no-source 2 'map)) ; require error check
+                     ls)))
+          (else (build-application no-source
+                  (build-primref no-source (car x))
+                  (map regen (cdr x)))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ x)
+           (let-values (((e maps) (gen-syntax e (syntax x) r '() ellipsis? #f)))
+             (regen e)))
+          (_ (syntax-error e)))))))
+
+
+(global-extend 'core 'lambda
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ . c)
+       (let-values (((vars body)
+                     (chi-lambda-clause 
+                       (source-wrap e w ae) 
+                       (syntax c) r mr w m?)))
+         (build-lambda ae vars body))))))
+
+;;; AZIZ
+(global-extend 'core 'case-lambda
+   (lambda (e r mr w ae m?)
+     (syntax-case e ()
+       [(_ c* ...)
+        (let-values ([(vars* body*)
+                      (let f ([c* #'(c* ...)])
+                        (syntax-case c* ()
+                          [() (values '() '())]
+                          [(c . c*) 
+                           (let-values ([(vars body)
+                                         (chi-lambda-clause
+                                           (source-wrap e w ae)
+                                           #'c r mr w m?)])
+                             (let-values ([(vars* body*) (f #'c*)])
+                               (values 
+                                 (cons vars vars*)
+                                 (cons body body*))))]))])
+           (build-case-lambda ae vars* body*))])))
+
+
+
+
+(global-extend 'core 'letrec
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae) "bound variable")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (let ((w (make-binding-wrap ids labels w))
+                    (r (extend-var-env* labels new-vars r)))
+                 (build-letrec ae
+                   new-vars
+                   (map (lambda (x) (chi x r mr w m?)) (syntax (val ...)))
+                   (chi-body (syntax (e1 e2 ...)) (source-wrap e w ae) r mr w m?)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'core 'if
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ test then)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi-void)))
+         ((_ test then else)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi (syntax else) r mr w m?)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+;;; AZIZ
+(global-extend 'core 'foreign-call
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-foreign-call ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+(global-extend 'core '$apply
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-$apply ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+;;; AZIZ
+(global-extend 'core 'type-descriptor
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ id)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             (($rtd) 
+              (build-data ae (binding-value b)))
+             (else (syntax-error (source-wrap e w ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'set! 'set! '())
+
+(global-extend 'alias 'alias '())
+(global-extend 'begin 'begin '())
+
+(global-extend '$module-key '$module '())
+(global-extend '$import '$import '())
+
+(global-extend 'define 'define '())
+
+(global-extend 'define-syntax 'define-syntax '())
+
+(global-extend 'eval-when 'eval-when '())
+
+(global-extend 'meta 'meta '())
+
+(global-extend 'core 'syntax-case
+  (let ()
+    (define convert-pattern
+      ; accepts pattern & keys
+      ; returns syntax-dispatch pattern & ids
+      (lambda (pattern keys)
+        (define cvt*
+          (lambda (p* n ids)
+            (if (null? p*)
+                (values '() ids)
+                (let-values (((y ids) (cvt* (cdr p*) n ids)))
+                  (let-values (((x ids) (cvt (car p*) n ids)))
+                    (values (cons x y) ids))))))
+        (define cvt
+          (lambda (p n ids)
+            (if (id? p)
+                (if (bound-id-member? p keys)
+                    (values (vector 'free-id p) ids)
+                    (values 'any (cons (cons p n) ids)))
+                (syntax-case p ()
+                  ((x dots)
+                   (ellipsis? (syntax dots))
+                   (let-values (((p ids) (cvt (syntax x) (fx+ n 1) ids)))
+                     (values (if (eq? p 'any) 'each-any (vector 'each p))
+                             ids)))
+                  ((x dots y ... . z)
+                   (ellipsis? (syntax dots))
+                   (let-values (((z ids) (cvt (syntax z) n ids)))
+                     (let-values (((y ids) (cvt* (syntax (y ...)) n ids)))
+                       (let-values (((x ids) (cvt (syntax x) (fx+ n 1) ids)))
+                         (values `#(each+ ,x ,(reverse y) ,z) ids)))))
+                  ((x . y)
+                   (let-values (((y ids) (cvt (syntax y) n ids)))
+                     (let-values (((x ids) (cvt (syntax x) n ids)))
+                       (values (cons x y) ids))))
+                  (() (values '() ids))
+                  (#(x ...)
+                   (let-values (((p ids) (cvt (syntax (x ...)) n ids)))
+                     (values (vector 'vector p) ids)))
+                  (x (values (vector 'atom (strip p empty-wrap)) ids))))))
+        (cvt pattern 0 '())))
+
+    (define build-dispatch-call
+      (lambda (pvars exp y r mr m?)
+        (let ((ids (map car pvars)) (levels (map cdr pvars)))
+          (let ((labels (gen-labels ids)) (new-vars (map gen-var ids)))
+            (build-application no-source
+              (build-primref no-source 'apply)
+              (list (build-lambda no-source new-vars
+                      (chi exp
+                         (extend-env*
+                             labels
+                             (map (lambda (var level)
+                                    (make-binding 'syntax `(,var . ,level)))
+                                  new-vars
+                                  (map cdr pvars))
+                             r)
+                         mr
+                         (make-binding-wrap ids labels empty-wrap)
+                         m?))
+                    y))))))
+
+    (define gen-clause
+      (lambda (x keys clauses r mr m? pat fender exp)
+        (let-values (((p pvars) (convert-pattern pat keys)))
+          (cond
+            ((not (distinct-bound-ids? (map car pvars)))
+             (invalid-ids-error (map car pvars) pat "pattern variable"))
+            ((not (andmap (lambda (x) (not (ellipsis? (car x)))) pvars))
+             (syntax-error pat
+               "misplaced ellipsis in syntax-case pattern"))
+            (else
+             (let ((y (gen-var 'tmp)))
+               ; fat finger binding and references to temp variable y
+               (build-application no-source
+                 (build-lambda no-source (list y)
+                   (let-syntax ((y (identifier-syntax
+                                     (build-lexical-reference 'value no-source y))))
+                     (build-conditional no-source
+                       (syntax-case fender ()
+                         (#t y)
+                         (_ (build-conditional no-source
+                              y
+                              (build-dispatch-call pvars fender y r mr m?)
+                              (build-data no-source #f))))
+                       (build-dispatch-call pvars exp y r mr m?)
+                       (gen-syntax-case x keys clauses r mr m?))))
+                 (list (if (eq? p 'any)
+                           (build-application no-source
+                             (build-primref no-source 'list)
+                             (list (build-lexical-reference no-source 'value x)))
+                           (build-application no-source
+                             (build-primref no-source '$syntax-dispatch)
+                             (list (build-lexical-reference no-source 'value x)
+                                   (build-data no-source p))))))))))))
+
+    (define gen-syntax-case
+      (lambda (x keys clauses r mr m?)
+        (if (null? clauses)
+            (build-application no-source
+              (build-primref no-source 'syntax-error)
+              (list (build-lexical-reference 'value no-source x)))
+            (syntax-case (car clauses) ()
+              ((pat exp)
+               (if (and (id? (syntax pat))
+                        (not (bound-id-member? (syntax pat) keys))
+                        (not (ellipsis? (syntax pat))))
+                   (let ((label (gen-label))
+                         (var (gen-var (syntax pat))))
+                     (build-application no-source
+                       (build-lambda no-source (list var)
+                         (chi (syntax exp)
+                              (extend-env label (make-binding 'syntax `(,var . 0)) r)
+                              mr
+                              (make-binding-wrap (syntax (pat))
+                                (list label) empty-wrap)
+                              m?))
+                       (list (build-lexical-reference 'value no-source x))))
+                   (gen-clause x keys (cdr clauses) r mr m?
+                     (syntax pat) #t (syntax exp))))
+              ((pat fender exp)
+               (gen-clause x keys (cdr clauses) r mr m?
+                 (syntax pat) (syntax fender) (syntax exp)))
+              (_ (syntax-error (car clauses) "invalid syntax-case clause"))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ val (key ...) m ...)
+           (if (andmap (lambda (x) (and (id? x) (not (ellipsis? x))))
+                       (syntax (key ...)))
+               (let ((x (gen-var 'tmp)))
+                 ; fat finger binding and references to temp variable x
+                 (build-application ae
+                   (build-lambda no-source (list x)
+                     (gen-syntax-case x
+                       (syntax (key ...)) (syntax (m ...))
+                       r mr m?))
+                   (list (chi (syntax val) r mr empty-wrap m?))))
+               (syntax-error e "invalid literals list in"))))))))
+
+(put-cte-hook 'module
+  (lambda (x)
+    (define proper-export?
+      (lambda (e)
+        (syntax-case e ()
+          ((id e ...)
+           (and (identifier? (syntax id))
+                (andmap proper-export? (syntax (e ...)))))
+          (id (identifier? (syntax id))))))
+    (with-syntax ((orig x))
+      (syntax-case x ()
+        ((_ (e ...) d ...)
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               (begin 
+                 ($module orig anon (e ...) d ...)
+                 ($import orig #f anon)))
+             (syntax-error x "invalid exports list in")))
+        ((_ m (e ...) d ...)
+         (identifier? (syntax m))
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               ($module orig m (e ...) d ...))
+             (syntax-error x "invalid exports list in")))))))
+
+(let ()
+  (define $module-exports
+    (lambda (m r)
+      (let ((b (r m)))
+        (case (binding-type b)
+          (($module)
+           (let* ((interface (binding-value b))
+                  (new-marks (import-mark-delta m interface)))
+             (vmap (lambda (x)
+                     (let ((id (if (pair? x) (car x) x)))
+                       (make-syntax-object
+                         (syntax-object->datum id)
+                         (let ((marks (join-marks new-marks (wrap-marks (syntax-object-wrap id))))) 
+                           (make-wrap marks
+                                     ; the anti mark should always be present at the head
+                                     ; of new-marks, but we paranoically check anyway
+                                      (if (eq? (car marks) the-anti-mark)
+                                          (cons 'shift (wrap-subst top-wrap))
+                                          (wrap-subst top-wrap)))))))
+                   (interface-exports interface))))
+          ((displaced-lexical) (displaced-lexical-error m))
+          (else (syntax-error m "unknown module"))))))
+  (define $import-help
+    (lambda (orig import-only?)
+      (lambda (r)
+        (define difference
+          (lambda (ls1 ls2)
+            (if (null? ls1)
+                ls1
+                (if (bound-id-member? (car ls1) ls2)
+                    (difference (cdr ls1) ls2)
+                    (cons (car ls1) (difference (cdr ls1) ls2))))))
+        (define prefix-add
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (datum->syntax-object id
+                  (string->symbol
+                    (string-append prefix
+                      (symbol->string (syntax-object->datum id)))))))))
+        (define prefix-drop
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (let ((s (symbol->string (syntax-object->datum id))))
+                  (let ((np (string-length prefix)) (ns (string-length s)))
+                    (unless (and (fx>= ns np) (string=? (substring s 0 np) prefix))
+                      (syntax-error id (string-append "missing expected prefix " prefix)))
+                    (datum->syntax-object id
+                      (string->symbol (substring s np ns)))))))))
+        (define gen-mid
+          (lambda (mid)
+           ; introduced module ids must have same marks as original
+           ; for import-only, since the barrier carries the marks of
+           ; the module id
+            (datum->syntax-object mid (gensym-hook))))
+        (define (modspec m exports?)
+          (with-syntax ((orig orig) (import-only? import-only?))
+            (syntax-case m (only-for-syntax also-for-syntax
+                            only except
+                            add-prefix drop-prefix rename alias)
+              ((only m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #f)))
+                 (with-syntax ((d d) (tmid (gen-mid mid)))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((except m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((id ...) (difference exports (syntax (id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((add-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-add (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((drop-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-drop (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((rename m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((tmp ...) (generate-temporaries (syntax (old-id ...))))
+                               ((other-id ...) (difference exports (syntax (old-id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id tmp) ... other-id ...)
+                                            ($module orig tmid (other-id ... (tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias new-id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+              ((alias m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((other-id ...) exports))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id old-id) ... other-id ...) d (alias new-id old-id) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+             ; base cases
+              (mid
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+              ((mid)
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+            (_ (syntax-error m "invalid module specifier")))))
+        (define modspec*
+          (lambda (m)
+            (let-values (((mid d exports) (modspec m #f))) d)))
+        (syntax-case orig ()
+          ((_ m ...)
+           (with-syntax (((d ...) (map modspec* (syntax (m ...)))))
+             (syntax (begin d ...))))))))
+
+  (put-cte-hook 'import
+    (lambda (orig)
+      ($import-help orig #f)))
+  
+  (put-cte-hook 'import-only
+    (lambda (orig)
+      ($import-help orig #t)))
+)
+
+;;; To support eval-when, we maintain two mode sets:
+;;;
+;;; ctem (compile-time-expression mode)
+;;;   determines whether/when to evaluate compile-time expressions such
+;;;   as macro definitions, module definitions, and compile-time
+;;;   registration of variable definitions
+;;;
+;;; rtem (run-time-expression mode)
+;;;   determines whether/when to evaluate run-time expressions such
+;;;   as the actual assignment performed by a variable definition or
+;;;   arbitrary top-level expressions
+
+;;; Possible modes in the mode set are:
+;;;
+;;; L (load): evaluate at load time.  implies V for compile-time
+;;;     expressions and R for run-time expressions.
+;;;
+;;; C (compile): evaluate at compile (file) time
+;;;
+;;; E (eval): evaluate at evaluation (compile or interpret) time
+;;;
+;;; V (visit): evaluate at visit time
+;;;
+;;; R (revisit): evaluate at revisit time
+
+;;; The mode set for the body of an eval-when is determined by
+;;; translating each mode in the old mode set based on the situations
+;;; present in the eval-when form and combining these into a set,
+;;; using the following table.  See also update-mode-set.
+
+;;;      load  compile  visit  revisit  eval
+;;;
+;;; L     L      C        V       R      -
+;;;
+;;; C     -      -        -       -      C
+;;;
+;;; V     V      C        V       -      -
+;;;
+;;; R     R      C        -       R      -
+;;;
+;;; E     -      -        -       -      E
+
+;;; When we complete the expansion of a compile or run-time expression,
+;;; the current ctem or rtem determines how the expression will be
+;;; treated.  See ct-eval/residualize and rt-eval/residualize.
+
+;;; Initial mode sets
+;;;
+;;; when compiling a file:
+;;;
+;;;     initial ctem: (L C)
+;;;
+;;;     initial rtem: (L)
+;;;
+;;; when not compiling a file:
+;;;
+;;;     initial ctem: (E)
+;;;
+;;;     initial rtem: (E)
+;;;
+;;;
+;;; This means that top-level syntactic definitions are evaluated
+;;; immediately after they are expanded, and the expanded definitions
+;;; are also residualized into the object file if we are compiling
+;;; a file.
+
+
+
+;;; AZIZ
+;;; (set! sc-expand
+;;;   (let ((ctem '(E)) (rtem '(E)))
+;;;     (lambda (x)
+;;;       (let ((env (interaction-environment)))
+;;;         (if (and (pair? x) (equal? (car x) noexpand))
+;;;             (cadr x)
+;;;             (chi-top* x null-env
+;;;               (env-wrap env)
+;;;               ctem rtem #f
+;;;               (env-top-ribcage env)))))))
+;;; 
+
+(primitive-set! 'expand-mode
+  (make-parameter
+    'eval
+    (lambda (x)
+      (unless (memq x '(eval compile bootstrap))
+        (error 'expand-mode "~s is not a valid mode" x))
+      x)))
+
+(primitive-set! 'sc-expand
+  (let ()
+    (define get-modes
+      (lambda ()
+        (case (expand-mode)
+          [(eval)      (values '(E)   '(E))]
+          [(compile)   (values '(L C) '(L))]
+          [(bootstrap) (values '(L)   '(L))])))
+    (lambda (x)
+      (let ((env (interaction-environment)))
+        (let-values ([(ctem rtem) (get-modes)])
+          (if (and (pair? x) (equal? (car x) noexpand))
+              (cadr x)
+              (chi-top* x null-env
+                (env-wrap env)
+                ctem rtem #f
+                (env-top-ribcage env))))))))
+
+(primitive-set! 'current-expand
+  (make-parameter
+    sc-expand
+    (lambda (x)
+      (unless (procedure? x)
+        (error 'current-expand "~s is not a procedure" x))
+      x)))
+
+(primitive-set! 'expand
+  (lambda (x)
+    ((current-expand) x)))
+
+(primitive-set! '$make-environment
+  (lambda (token mutable?)
+    (let ((top-ribcage (make-top-ribcage token mutable?)))
+      (make-env
+        top-ribcage
+        (make-wrap
+          (wrap-marks top-wrap)
+          (cons top-ribcage (wrap-subst top-wrap)))))))
+
+(primitive-set! 'environment?
+  (lambda (x)
+    (env? x)))
+
+
+;;; AZIZ
+;;; (primitive-set! 'interaction-environment
+;;;   (let ((e ($make-environment '*top* #t)))
+;;;     (lambda () e)))
+
+(primitive-set! 'interaction-environment
+  (make-parameter
+    ($make-environment '*top* #t)
+    (lambda (x)
+      (if (environment? x)
+          x
+          (error 'interaction-environment "~s is not an environment" x)))))
+
+
+(primitive-set! 'identifier?
+  (lambda (x)
+    (nonsymbol-id? x)))
+
+(primitive-set! 'datum->syntax-object
+  (lambda (id datum)
+    (arg-check nonsymbol-id? id 'datum->syntax-object)
+    (make-syntax-object
+      datum
+      (syntax-object-wrap id))))
+
+(primitive-set! 'syntax->list
+  (lambda (orig-ls)
+    (let f ((ls orig-ls))
+      (syntax-case ls ()
+        (() '())
+        ((x . r) (cons #'x (f #'r)))
+        (_ (error 'syntax->list "invalid argument ~s" orig-ls))))))
+
+(primitive-set! 'syntax->vector
+  (lambda (v)
+    (syntax-case v ()
+      (#(x ...) (apply vector (syntax->list #'(x ...))))
+      (_ (error 'syntax->vector "invalid argument ~s" v)))))
+
+(primitive-set! 'syntax-object->datum
+  ; accepts any object, since syntax objects may consist partially
+  ; or entirely of unwrapped, nonsymbolic data
+  (lambda (x)
+    (strip x empty-wrap)))
+
+(primitive-set! 'generate-temporaries
+  (lambda (ls)
+    (arg-check list? ls 'generate-temporaries)
+    (map (lambda (x) (wrap (gensym-hook) top-wrap)) ls)))
+
+(primitive-set! 'free-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'free-identifier=?)
+      (arg-check nonsymbol-id? y 'free-identifier=?)
+      (free-id=? x y)))
+
+(primitive-set! 'bound-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'bound-identifier=?)
+      (arg-check nonsymbol-id? y 'bound-identifier=?)
+      (bound-id=? x y)))
+
+(primitive-set! 'literal-identifier=?
+  (lambda (x y)
+    (arg-check nonsymbol-id? x 'literal-identifier=?)
+    (arg-check nonsymbol-id? y 'literal-identifier=?)
+    (literal-id=? x y)))
+
+(primitive-set! 'syntax-error
+  (lambda (object . messages)
+    (for-each (lambda (x) (arg-check string? x 'syntax-error)) messages)
+    (let ((message (if (null? messages)
+                       "invalid syntax"
+                       (apply string-append messages))))
+      (error-hook #f message (strip object empty-wrap)))))
+
+;;; syntax-dispatch expects an expression and a pattern.  If the expression
+;;; matches the pattern a list of the matching expressions for each
+;;; "any" is returned.  Otherwise, #f is returned.  (This use of #f will
+;;; not work on r4rs implementations that violate the ieee requirement
+;;; that #f and () be distinct.)
+
+;;; The expression is matched with the pattern as follows:
+
+;;; p in pattern:                        matches:
+;;;   ()                                 empty list
+;;;   any                                anything
+;;;   (p1 . p2)                          pair (list)
+;;;   #(free-id <key>)                   <key> with literal-identifier=?
+;;;   each-any                           any proper list
+;;;   #(each p)                          (p*)
+;;;   #(each+ p1 (p2_1 ...p2_n) p3)      (p1* (p2_n ... p2_1) . p3)
+;;;   #(vector p)                        (list->vector p)
+;;;   #(atom <object>)                   <object> with "equal?"
+
+;;; Vector cops out to pair under assumption that vectors are rare.  If
+;;; not, should convert to:
+;;;   #(vector p)                        #(p*)
+
+(let ()
+
+(define match-each
+  (lambda (e p w)
+    (cond
+      ((annotation? e)
+       (match-each (annotation-expression e) p w))
+      ((pair? e)
+       (let ((first (match (car e) p w '())))
+         (and first
+              (let ((rest (match-each (cdr e) p w)))
+                 (and rest (cons first rest))))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each (syntax-object-expression e)
+                   p
+                   (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-each+
+  (lambda (e x-pat y-pat z-pat w r)
+    (let f ((e e) (w w))
+      (cond
+        ((pair? e)
+         (let-values (((xr* y-pat r) (f (cdr e) w)))
+           (if r
+               (if (null? y-pat)
+                   (let ((xr (match (car e) x-pat w '())))
+                     (if xr
+                         (values (cons xr xr*) y-pat r)
+                         (values #f #f #f)))
+                   (values '() (cdr y-pat) (match (car e) (car y-pat) w r)))
+               (values #f #f #f))))
+        ((annotation? e) (f (annotation-expression e) w))
+        ((syntax-object? e) (f (syntax-object-expression e)
+                               (join-wraps w (syntax-object-wrap e))))
+        (else (values '() y-pat (match e z-pat w r)))))))
+
+(define match-each-any
+  (lambda (e w)
+    (cond
+      ((annotation? e)
+       (match-each-any (annotation-expression e) w))
+      ((pair? e)
+       (let ((l (match-each-any (cdr e) w)))
+         (and l (cons (wrap (car e) w) l))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each-any (syntax-object-expression e)
+                       (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-empty
+  (lambda (p r)
+    (cond
+      ((null? p) r)
+      ((eq? p 'any) (cons '() r))
+      ((pair? p) (match-empty (car p) (match-empty (cdr p) r)))
+      ((eq? p 'each-any) (cons '() r))
+      (else
+       (case (vector-ref p 0)
+         ((each) (match-empty (vector-ref p 1) r))
+         ((each+) (match-empty (vector-ref p 1)
+                    (match-empty (reverse (vector-ref p 2))
+                      (match-empty (vector-ref p 3) r))))
+         ((free-id atom) r)
+         ((vector) (match-empty (vector-ref p 1) r)))))))
+
+(define combine
+  (lambda (r* r)
+    (if (null? (car r*))
+        r
+        (cons (map car r*) (combine (map cdr r*) r)))))
+
+(define match*
+  (lambda (e p w r)
+    (cond
+      ((null? p) (and (null? e) r))
+      ((pair? p)
+       (and (pair? e) (match (car e) (car p) w
+                        (match (cdr e) (cdr p) w r))))
+      ((eq? p 'each-any)
+       (let ((l (match-each-any e w))) (and l (cons l r))))
+      (else
+       (case (vector-ref p 0)
+         ((each)
+          (if (null? e)
+              (match-empty (vector-ref p 1) r)
+              (let ((r* (match-each e (vector-ref p 1) w)))
+                (and r* (combine r* r)))))
+         ((free-id) (and (id? e) (literal-id=? (wrap e w) (vector-ref p 1)) r))
+         ((each+)
+          (let-values (((xr* y-pat r)
+                        (match-each+ e (vector-ref p 1) (vector-ref p 2)
+                          (vector-ref p 3) w r)))
+            (and r (null? y-pat)
+              (if (null? xr*)
+                  (match-empty (vector-ref p 1) r)
+                  (combine xr* r)))))
+         ((atom) (and (equal? (vector-ref p 1) (strip e w)) r))
+         ((vector)
+          (and (vector? e)
+               (match (vector->list e) (vector-ref p 1) w r))))))))
+
+(define match
+  (lambda (e p w r)
+    (cond
+      ((not r) #f)
+      ((eq? p 'any) (cons (wrap e w) r))
+      ((syntax-object? e)
+       (match*
+         (unannotate (syntax-object-expression e))
+         p
+         (join-wraps w (syntax-object-wrap e))
+         r))
+      (else (match* (unannotate e) p w r)))))
+
+(primitive-set! '$syntax-dispatch
+  (lambda (e p)
+    (cond
+      ((eq? p 'any) (list e))
+      ((syntax-object? e)
+       (match* (unannotate (syntax-object-expression e))
+         p (syntax-object-wrap e) '()))
+      (else (match* (unannotate e) p empty-wrap '())))))
+))
+
+
+(define-syntax with-syntax
+   (lambda (x)
+      (syntax-case x ()
+         ((_ () e1 e2 ...)
+          (syntax (begin e1 e2 ...)))
+         ((_ ((out in)) e1 e2 ...)
+          (syntax (syntax-case in () (out (begin e1 e2 ...)))))
+         ((_ ((out in) ...) e1 e2 ...)
+          (syntax (syntax-case (list in ...) ()
+                     ((out ...) (begin e1 e2 ...))))))))
+
+(define-syntax with-implicit
+  (syntax-rules ()
+    ((_ (tid id ...) e1 e2 ...)
+     (andmap identifier? (syntax (tid id ...)))
+     (begin
+       (unless (identifier? (syntax tid))
+         (syntax-error (syntax tid) "non-identifier with-implicit template"))
+       (with-syntax ((id (datum->syntax-object (syntax tid) 'id)) ...)
+         e1 e2 ...)))))
+
+(define-syntax datum
+  (syntax-rules ()
+    ((_ x) (syntax-object->datum (syntax x)))))
+
+(define-syntax syntax-rules
+  (lambda (x)
+    (define clause
+      (lambda (y)
+        (syntax-case y ()
+          (((keyword . pattern) template)
+           (syntax ((dummy . pattern) (syntax template))))
+          (((keyword . pattern) fender template)
+           (syntax ((dummy . pattern) fender (syntax template))))
+          (_ (syntax-error x)))))
+    (syntax-case x ()
+      ((_ (k ...) cl ...)
+       (andmap identifier? (syntax (k ...)))
+       (with-syntax (((cl ...) (map clause (syntax (cl ...)))))
+         (syntax (lambda (x) (syntax-case x (k ...) cl ...))))))))
+
+(define-syntax or
+   (lambda (x)
+      (syntax-case x ()
+         ((_) (syntax #f))
+         ((_ e) (syntax e))
+         ((_ e1 e2 e3 ...)
+          (syntax (let ((t e1)) (if t t (or e2 e3 ...))))))))
+
+(define-syntax and
+   (lambda (x)
+      (syntax-case x ()
+         ((_ e1 e2 e3 ...) (syntax (if e1 (and e2 e3 ...) #f)))
+         ((_ e) (syntax e))
+         ((_) (syntax #t)))))
+
+(define-syntax let
+   (lambda (x)
+      (syntax-case x ()
+         ((_ ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (x ...)))
+          (syntax ((lambda (x ...) e1 e2 ...) v ...)))
+         ((_ f ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (f x ...)))
+          (syntax ((letrec ((f (lambda (x ...) e1 e2 ...))) f)
+                    v ...))))))
+
+(define-syntax let*
+  (lambda (x)
+    (syntax-case x ()
+      ((let* ((x v) ...) e1 e2 ...)
+       (andmap identifier? (syntax (x ...)))
+       (let f ((bindings (syntax ((x v)  ...))))
+         (if (null? bindings)
+             (syntax (let () e1 e2 ...))
+             (with-syntax ((body (f (cdr bindings)))
+                           (binding (car bindings)))
+               (syntax (let (binding) body)))))))))
+
+(define-syntax cond
+  (lambda (x)
+    (syntax-case x ()
+      ((_ m1 m2 ...)
+       (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+         (if (null? clauses)
+             (syntax-case clause (else =>)
+               ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+               ((e0) (syntax (let ((t e0)) (if t t))))
+               ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
+               ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...))))
+               (_ (syntax-error x)))
+             (with-syntax ((rest (f (car clauses) (cdr clauses))))
+               (syntax-case clause (else =>)
+                 ((e0) (syntax (let ((t e0)) (if t t rest))))
+                 ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
+                 ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...) rest)))
+                 (_ (syntax-error x))))))))))
+
+(define-syntax do
+   (lambda (orig-x)
+      (syntax-case orig-x ()
+         ((_ ((var init . step) ...) (e0 e1 ...) c ...)
+          (with-syntax (((step ...)
+                         (map (lambda (v s)
+                                 (syntax-case s ()
+                                    (() v)
+                                    ((e) (syntax e))
+                                    (_ (syntax-error orig-x))))
+                              (syntax (var ...))
+                              (syntax (step ...)))))
+             (syntax-case (syntax (e1 ...)) ()
+                (() (syntax (let do ((var init) ...)
+                               (if (not e0)
+                                   (begin c ... (do step ...))))))
+                ((e1 e2 ...)
+                 (syntax (let do ((var init) ...)
+                            (if e0
+                                (begin e1 e2 ...)
+                                (begin c ... (do step ...))))))))))))
+
+(define-syntax quasiquote
+   (letrec
+     ; these are here because syntax-case uses literal-identifier=?,
+     ; and we want the more precise free-identifier=?
+      ((isquote? (lambda (x)
+                   (and (identifier? x)
+                        (free-identifier=? x (syntax quote)))))
+       (islist? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax list)))))
+       (iscons? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax cons)))))
+       (quote-nil? (lambda (x)
+                    (syntax-case x ()
+                      ((quote? ()) (isquote? (syntax quote?)))
+                      (_ #f))))
+       (quasilist*
+        (lambda (x y)
+          (let f ((x x))
+            (if (null? x)
+                y
+                (quasicons (car x) (f (cdr x)))))))
+       (quasicons
+        (lambda (x y)
+          (with-syntax ((x x) (y y))
+            (syntax-case (syntax y) ()
+              ((quote? dy)
+               (isquote? (syntax quote?))
+               (syntax-case (syntax x) ()
+                 ((quote? dx)
+                  (isquote? (syntax quote?))
+                  (syntax (quote (dx . dy))))
+                 (_ (if (null? (syntax dy))
+                        (syntax (list x))
+                        (syntax (cons x y))))))
+              ((listp . stuff)
+               (islist? (syntax listp))
+               (syntax (list x . stuff)))
+              (else (syntax (cons x y)))))))
+       (quasiappend
+        (lambda (x y)
+          (let ((ls (let f ((x x))
+                      (if (null? x)
+                          (if (quote-nil? y)
+                              '()
+                              (list y))
+                          (if (quote-nil? (car x))
+                              (f (cdr x))
+                              (cons (car x) (f (cdr x))))))))
+            (cond
+              ((null? ls) (syntax (quote ())))
+              ((null? (cdr ls)) (car ls))
+              (else (with-syntax (((p ...) ls))
+                      (syntax (append p ...))))))))
+       (quasivector
+        (lambda (x)
+          (with-syntax ((pat-x x))
+            (syntax-case (syntax pat-x) ()
+              ((quote? (x ...))
+               (isquote? (syntax quote?))
+               (syntax (quote #(x ...))))
+              (_ (let f ((x x) (k (lambda (ls) `(,(syntax vector) ,@ls))))
+                   (syntax-case x ()
+                     ((quote? (x ...))
+                      (isquote? (syntax quote?))
+                      (k (syntax ((quote x) ...))))
+                     ((listp x ...)
+                      (islist? (syntax listp))
+                      (k (syntax (x ...))))
+                     ((cons? x y)
+                      (iscons? (syntax cons?))
+                      (f (syntax y) (lambda (ls) (k (cons (syntax x) ls)))))
+                     (else
+                      (syntax (list->vector pat-x))))))))))
+       (vquasi
+        (lambda (p lev)
+           (syntax-case p ()
+              ((p . q)
+               (syntax-case #'p (unquote unquote-splicing)
+                 ((unquote p ...)
+                  (if (fx= lev 0)
+                      (quasilist* (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 ((unquote-splicing p ...)
+                  (if (fx= lev 0)
+                      (quasiappend (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote-splicing))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 (p (quasicons (quasi (syntax p) lev) (vquasi (syntax q) lev)))))
+              (() (syntax (quote ()))))))
+       (quasi
+        (lambda (p lev)
+           (syntax-case p (unquote unquote-splicing quasiquote)
+              ((unquote p)
+               (if (fx= lev 0)
+                   (syntax p)
+                   (quasicons (syntax (quote unquote))
+                              (quasi (syntax (p)) (fx- lev 1)))))
+              (((unquote p ...) . q)
+               (if (fx= lev 0)
+                   (quasilist* (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              (((unquote-splicing p ...) . q)
+               (if (fx= lev 0)
+                   (quasiappend (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote-splicing))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              ((quasiquote p)
+               (quasicons (syntax (quote quasiquote))
+                          (quasi (syntax (p)) (fx+ lev 1))))
+              ((p . q)
+               (quasicons (quasi (syntax p) lev) (quasi (syntax q) lev)))
+              (#(x ...) (quasivector (vquasi (syntax (x ...)) lev)))
+              (p (syntax (quote p)))))))
+    (lambda (x)
+       (syntax-case x ()
+          ((_ e) (quasi (syntax e) 0))))))
+
+(define-syntax unquote
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unquote-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax quasisyntax
+  (lambda (x)
+    (define (qs q n b* k)
+      (syntax-case q (quasisyntax unsyntax unsyntax-splicing)
+        ((quasisyntax . d)
+         (qs #'d (fx+ n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(quasisyntax . d)))))))
+        ((unsyntax . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax . d)))))))
+        ((unsyntax-splicing . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax-splicing . d)))))))
+        ((unsyntax q)
+         (fx= n 0)
+         (with-syntax (((t) (generate-temporaries #'(q))))
+           (k (cons #'(t q) b*) #'t)))
+        (((unsyntax q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'((t q) ...) b*)
+                  (with-syntax ((d dnew)) #'(t ... . d)))))))
+        (((unsyntax-splicing q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'(((t (... ...)) q) ...) b*)
+                  (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                    (with-syntax ((d dnew)) #'(m ... ... . d))))))))
+        ((a . d)
+         (qs #'a n b*
+           (lambda (b* anew)
+             (qs #'d n b*
+               (lambda (b* dnew)
+                 (k b*
+                    (if (and (eq? anew #'a) (eq? dnew #'d))
+                        q
+                        (with-syntax ((a anew) (d dnew)) #'(a . d)))))))))
+        (#(x ...)
+         (vqs #'(x ...) n b*
+           (lambda (b* xnew*)
+             (k b*
+                (if (let same? ((x* #'(x ...)) (xnew* xnew*))
+                      (if (null? x*)
+                          (null? xnew*)
+                          (and (not (null? xnew*))
+                               (eq? (car x*) (car xnew*))
+                               (same? (cdr x*) (cdr xnew*)))))
+                    q
+                    (with-syntax (((x ...) xnew*)) #'#(x ...)))))))
+        (_ (k b* q))))
+    (define (vqs x* n b* k)
+      (if (null? x*)
+          (k b* '())
+          (vqs (cdr x*) n b*
+            (lambda (b* xnew*)
+              (syntax-case (car x*) (unsyntax unsyntax-splicing)
+                ((unsyntax q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'((t q) ...) b*)
+                      (append #'(t ...) xnew*))))
+                ((unsyntax-splicing q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'(((t (... ...)) q) ...) b*)
+                      (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                        (append #'(m ... ...) xnew*)))))
+                (_ (qs (car x*) n b*
+                     (lambda (b* xnew)
+                       (k b* (cons xnew xnew*))))))))))
+    (syntax-case x ()
+      ((_ x)
+       (qs #'x 0 '()
+         (lambda (b* xnew)
+           (if (eq? xnew #'x)
+               #'(syntax x)
+               (with-syntax (((b ...) b*) (x xnew))
+                 #'(with-syntax (b ...) (syntax x))))))))))
+
+(define-syntax unsyntax
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unsyntax-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax include
+  (lambda (x)
+    (define read-file
+      (lambda (fn k)
+        (let ((p (open-input-file fn)))
+          (let f ()
+            (let ((x (read p)))
+              (if (eof-object? x)
+                  (begin (close-input-port p) '())
+                  (cons (datum->syntax-object k x) (f))))))))
+    (syntax-case x ()
+      ((k filename)
+       (let ((fn (syntax-object->datum (syntax filename))))
+         (with-syntax (((exp ...) (read-file fn (syntax k))))
+           (syntax (begin exp ...))))))))
+
+(define-syntax case
+  (lambda (x)
+    (syntax-case x ()
+      ((_ e m1 m2 ...)
+       (with-syntax
+         ((body (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+                  (if (null? clauses)
+                      (syntax-case clause (else)
+                        ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+                        (((k ...) e1 e2 ...)
+                         (syntax (if (memv t '(k ...)) (begin e1 e2 ...))))
+                        (_ (syntax-error x)))
+                      (with-syntax ((rest (f (car clauses) (cdr clauses))))
+                        (syntax-case clause (else)
+                          (((k ...) e1 e2 ...)
+                           (syntax (if (memv t '(k ...))
+                                       (begin e1 e2 ...)
+                                       rest)))
+                          (_ (syntax-error x))))))))
+         (syntax (let ((t e)) body)))))))
+
+(define-syntax identifier-syntax
+  (syntax-rules (set!)
+    ((_ e)
+     (lambda (x)
+       (syntax-case x ()
+         (id (identifier? (syntax id)) (syntax e))
+         ((_ x (... ...)) (syntax (e x (... ...)))))))
+    ((_ (id exp1) ((set! var val) exp2))
+     (and (identifier? (syntax id)) (identifier? (syntax var)))
+     (cons 'macro!
+       (lambda (x)
+         (syntax-case x (set!)
+           ((set! var val) (syntax exp2))
+           ((id x (... ...)) (syntax (exp1 x (... ...))))
+           (id (identifier? (syntax id)) (syntax exp1))))))))
+
+(define-syntax parameterize
+  (lambda (x)
+    (syntax-case x ()
+      [(_ () b b* ...) #'(let () b b* ...)]
+      [(_ ([olhs* orhs*] ...) b b* ...)
+       (with-syntax ([(lhs* ...) (generate-temporaries #'(olhs* ...))]
+                     [(rhs* ...) (generate-temporaries #'(orhs* ...))])
+        #'(let ([lhs* olhs*] ...
+                [rhs* orhs*] ...)
+            (let ([swap
+                   (lambda ()
+                     (let ([t (lhs*)])
+                       (lhs* rhs*)
+                       (set! rhs* t)) ...)])
+              (dynamic-wind
+                swap
+                (lambda () b b* ...)
+                swap))))])))
+
+(define-syntax when
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (begin b b* ...)
+         (void))]))
+
+(define-syntax unless
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (void)
+         (begin b b* ...))]))
+
+(define-syntax let-values
+  (lambda (x)
+    (define (bindem n** v**)
+      (syntax-case n** ()
+        [() #'()]
+        [((n* ...) . n**)
+         (syntax-case v** ()
+          [((v* ...) . v**)
+           (with-syntax ([rest (bindem #'n** #'v**)])
+             #'([n* v*] ... . rest))])]))
+    (syntax-case x ()
+      [(_ ([(name** ...) v*] ...) b b* ...)
+       (let ([n**
+              (let f ([n** #'((name** ...) ...)])
+                (syntax-case n** ()
+                  [() #'()]
+                  [(n* . n**)
+                   (with-syntax ([n* (generate-temporaries #'n*)]
+                                 [n** (f #'n**)])
+                     #'(n* . n**))]))])
+         (let f ([t** n**] [v* #'(v* ...)])
+           (syntax-case t** ()
+             [((t* ...) . t**) 
+              (syntax-case v* ()
+                [(v . v*)
+                 (with-syntax ([body (f #'t** #'v*)])
+                   #'(call-with-values
+                       (lambda () v)
+                       (lambda (t* ...) body)))])]
+             [() 
+              (with-syntax ([bind* (bindem #'((name** ...) ...) n**)])
+                #'(let bind* b b* ...))])))])))
+
+
+
+
+(define-syntax define-record
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append namestr "?")))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define constr (record-constructor 'rtd))
+                (define pred (record-predicate 'rtd))
+                (define getters (record-field-accessor 'rtd 'field*)) ...
+                (define setters (record-field-mutator 'rtd 'field*)) ...
+                )))])))
+
diff --git a/src/psyntax-7.1-6.8.ss b/src/psyntax-7.1-6.8.ss
new file mode 100644
index 0000000..9a57d6c
--- /dev/null
+++ b/src/psyntax-7.1-6.8.ss
@@ -0,0 +1,4616 @@
+;;; Portable implementation of syntax-case
+;;; Extracted from Chez Scheme Version 7.1 (Aug 01, 2006)
+;;; Authors: R. Kent Dybvig, Oscar Waddell, Bob Hieb, Carl Bruggeman
+
+;;; Copyright (c) 1992-2002 Cadence Research Systems
+;;; Permission to copy this software, in whole or in part, to use this
+;;; software for any lawful purpose, and to redistribute this software
+;;; is granted subject to the restriction that all copies made of this
+;;; software must include this copyright notice in full.  This software
+;;; is provided AS IS, with NO WARRANTY, EITHER EXPRESS OR IMPLIED,
+;;; INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY
+;;; OR FITNESS FOR ANY PARTICULAR PURPOSE.  IN NO EVENT SHALL THE
+;;; AUTHORS BE LIABLE FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY
+;;; NATURE WHATSOEVER.
+
+;;; Before attempting to port this code to a new implementation of
+;;; Scheme, please read the notes below carefully.
+
+;;; This file defines the syntax-case expander, sc-expand, and a set
+;;; of associated syntactic forms and procedures.  Of these, the
+;;; following are documented in The Scheme Programming Language,
+;;; Third Edition (R. Kent Dybvig, MIT Press, 2003), which can be
+;;; found online at http://www.scheme.com/tspl3/.  Most are also documented
+;;; in the R4RS and draft R5RS.
+;;;
+;;;   bound-identifier=?
+;;;   datum->syntax-object
+;;;   define-syntax
+;;;   fluid-let-syntax
+;;;   free-identifier=?
+;;;   generate-temporaries
+;;;   identifier?
+;;;   identifier-syntax
+;;;   let-syntax
+;;;   letrec-syntax
+;;;   syntax
+;;;   syntax-case
+;;;   syntax-object->datum
+;;;   syntax-rules
+;;;   with-syntax
+;;;
+;;; All standard Scheme syntactic forms are supported by the expander
+;;; or syntactic abstractions defined in this file.  Only the R4RS
+;;; delay is omitted, since its expansion is implementation-dependent.
+
+;;; Also defined are three forms that support modules: module, import,
+;;; and import-only.  These are documented in the Chez Scheme User's
+;;; Guide (R. Kent Dybvig, Cadence Research Systems, 1998), which can
+;;; also be found online at http://www.scheme.com/csug/.  They are
+;;; described briefly here as well.
+    
+;;; All are definitions and may appear where and only where other
+;;; definitions may appear.  modules may be named:
+;;;
+;;;   (module id (ex ...) defn ... init ...)
+;;;
+;;; or anonymous:
+;;;
+;;;   (module (ex ...) defn ... init ...)
+;;;
+;;; The latter form is semantically equivalent to:
+;;;
+;;;   (module T (ex ...) defn ... init ...)
+;;;   (import T)
+;;;
+;;; where T is a fresh identifier.
+;;;
+;;; In either form, each of the exports in (ex ...) is either an
+;;; identifier or of the form (id ex ...).  In the former case, the
+;;; single identifier ex is exported.  In the latter, the identifier
+;;; id is exported and the exports ex ... are "implicitly" exported.
+;;; This listing of implicit exports is useful only when id is a
+;;; keyword bound to a transformer that expands into references to
+;;; the listed implicit exports.  In the present implementation,
+;;; listing of implicit exports is necessary only for top-level
+;;; modules and allows the implementation to avoid placing all
+;;; identifiers into the top-level environment where subsequent passes
+;;; of the compiler will be unable to deal effectively with them.
+;;;
+;;; Named modules may be referenced in import statements, which
+;;; always take one of the forms:
+;;;
+;;;   (import id)
+;;;   (import-only id)
+;;;
+;;; id must name a module.  Each exported identifier becomes visible
+;;; within the scope of the import form.  In the case of import-only,
+;;; all other identifiers become invisible in the scope of the
+;;; import-only form, except for those established by definitions
+;;; that appear textually after the import-only form.
+
+;;; import and import-only also support a variety of identifier
+;;; selection and renaming forms: only, except, add-prefix,
+;;; drop-prefix, rename, and alias.
+;;;
+;;;   (import (only m x y))
+;;; 
+;;; imports x and y (and nothing else) from m.
+;;;
+;;;   (import (except m x y))
+;;; 
+;;; imports all of m's imports except for x and y.
+;;;
+;;;   (import (add-prefix (only m x y) m:))
+;;; 
+;;; imports x and y as m:x and m:y.
+;;;
+;;;   (import (drop-prefix m foo:))
+;;; 
+;;; imports all of m's imports, dropping the common foo: prefix
+;;; (which must appear on all of m's exports).
+;;; 
+;;;   (import (rename (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, renaming c
+;;; m-c and d m-d.
+;;; 
+;;;   (import (alias (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, with additional
+;;; aliases m-c for c and m-d for d.
+;;; 
+;;; multiple imports may be specified with one import form:
+;;; 
+;;;   (import (except m1 x) (only m2 x))
+;;; 
+;;; imports all of m1's exports except for x plus x from m2.
+
+;;; Another form, meta, may be used as a prefix for any definition and
+;;; causes any resulting variable bindings to be created at expansion
+;;; time.  Meta variables (variables defined using meta) are available
+;;; only at expansion time.  Meta definitions are often used to create
+;;; data and helpers that can be shared by multiple macros, for example:
+
+;;; (module (alpha beta)
+;;;   (meta define key-error
+;;;     (lambda (key)
+;;;       (syntax-error key "invalid key")))
+;;;   (meta define parse-keys
+;;;     (lambda (keys)
+;;;       (let f ((keys keys) (c #'white) (s 10))
+;;;         (syntax-case keys (color size)
+;;;           (() (list c s))
+;;;           (((color c) . keys) (f #'keys #'c s))
+;;;           (((size s) . keys) (f #'keys c #'s))
+;;;           ((k . keys) (key-error #'k))))))
+;;;   (define-syntax alpha
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---)))))
+;;;   (define-syntax beta
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---))))))
+
+;;; As with define-syntax rhs expressions, meta expressions can evaluate
+;;; references only to identifiers whose values are (already) available
+;;; in the compile-time environment, e.g., macros and meta variables.
+;;; They can, however, like define-syntax rhs expressions, build syntax
+;;; objects containing occurrences of any identifiers in their scope.
+
+;;; meta definitions propagate through macro expansion, so one can write,
+;;; for example:
+;;; 
+;;;   (module (a)
+;;;     (meta define-structure (foo x))
+;;;     (define-syntax a
+;;;       (let ((q (make-foo (syntax 'q))))
+;;;         (lambda (x)
+;;;           (foo-x q)))))
+;;;   a -> q
+;;; 
+;;; where define-record is a macro that expands into a set of defines.
+;;; 
+;;; It is also sometimes convenient to write
+;;; 
+;;;   (meta begin defn ...)
+;;; 
+;;; or
+;;; 
+;;;   (meta module {exports} defn ...)
+;;; 
+;;; to create groups of meta bindings.
+
+;;; Another form, alias, is used to create aliases from one identifier
+;;; to another.  This is used primarily to support the extended import
+;;; syntaxes (add-prefix, drop-prefix, rename, and alias).
+
+;;; (let ((x 3)) (alias y x) y) -> 3
+
+;;; The remaining exports are listed below.  sc-expand, eval-when, and
+;;; syntax-error are described in the Chez Scheme User's Guide.
+;;;
+;;;   (sc-expand datum)
+;;;      if datum represents a valid expression, sc-expand returns an
+;;;      expanded version of datum in a core language that includes no
+;;;      syntactic abstractions.  The core language includes begin,
+;;;      define, if, lambda, letrec, quote, and set!.
+;;;   (eval-when situations expr ...)
+;;;      conditionally evaluates expr ... at compile-time or run-time
+;;;      depending upon situations
+;;;   (syntax-error object message)
+;;;      used to report errors found during expansion
+;;;   ($syntax-dispatch e p)
+;;;      used by expanded code to handle syntax-case matching
+;;;   ($sc-put-cte symbol val top-token)
+;;;      used to establish top-level compile-time (expand-time) bindings.
+
+;;; The following nonstandard procedures must be provided by the
+;;; implementation for this code to run.
+;;;
+;;; (void)
+;;; returns the implementation's cannonical "unspecified value".  The
+;;; following usually works:
+;;;
+;;; (define void (lambda () (if #f #f))).
+;;;
+;;; (andmap proc list1 list2 ...)
+;;; returns true if proc returns true when applied to each element of list1
+;;; along with the corresponding elements of list2 ....  The following
+;;; definition works but does no error checking:
+;;;
+;;; (define andmap
+;;;   (lambda (f first . rest)
+;;;     (or (null? first)
+;;;         (if (null? rest)
+;;;             (let andmap ((first first))
+;;;               (let ((x (car first)) (first (cdr first)))
+;;;                 (if (null? first)
+;;;                     (f x)
+;;;                     (and (f x) (andmap first)))))
+;;;             (let andmap ((first first) (rest rest))
+;;;               (let ((x (car first))
+;;;                     (xr (map car rest))
+;;;                     (first (cdr first))
+;;;                     (rest (map cdr rest)))
+;;;                 (if (null? first)
+;;;                     (apply f (cons x xr))
+;;;                     (and (apply f (cons x xr)) (andmap first rest)))))))))
+;;;
+;;; (ormap proc list1)
+;;; returns the first non-false return result of proc applied to
+;;; the elements of list1 or false if none.  The following definition
+;;; works but does no error checking:
+;;;
+;;; (define ormap
+;;;   (lambda (proc list1)
+;;;     (and (not (null? list1))
+;;;          (or (proc (car list1)) (ormap proc (cdr list1))))))
+;;;
+;;; The following nonstandard procedures must also be provided by the
+;;; implementation for this code to run using the standard portable
+;;; hooks and output constructors.  They are not used by expanded code,
+;;; and so need be present only at expansion time.
+;;;
+;;; (eval x)
+;;; where x is always in the form ("noexpand" expr).
+;;; returns the value of expr.  the "noexpand" flag is used to tell the
+;;; evaluator/expander that no expansion is necessary, since expr has
+;;; already been fully expanded to core forms.
+;;;
+;;; eval will not be invoked during the loading of psyntax.pp.  After
+;;; psyntax.pp has been loaded, the expansion of any macro definition,
+;;; whether local or global, results in a call to eval.  If, however,
+;;; sc-expand has already been registered as the expander to be used
+;;; by eval, and eval accepts one argument, nothing special must be done
+;;; to support the "noexpand" flag, since it is handled by sc-expand.
+;;;
+;;; (error who format-string why what)
+;;; where who is either a symbol or #f, format-string is always "~a ~s",
+;;; why is always a string, and what may be any object.  error should
+;;; signal an error with a message something like
+;;;
+;;;    "error in <who>: <why> <what>"
+;;;
+;;; (gensym)
+;;; returns a unique symbol each time it's called.  In Chez Scheme, gensym
+;;; returns a symbol with a "globally" unique name so that gensyms that
+;;; end up in the object code of separately compiled files cannot conflict.
+;;; This is necessary only if you intend to support compiled files.
+;;;
+;;; (gensym? x)
+;;; returns #t if x is a gensym, otherwise false.
+;;;
+;;; (putprop symbol key value)
+;;; (getprop symbol key)
+;;; (remprop symbol key)
+;;; key is always a symbol; value may be any object.  putprop should
+;;; associate the given value with the given symbol and key in some way
+;;; that it can be retrieved later with getprop.  getprop should return
+;;; #f if no value is associated with the given symbol and key.  remprop
+;;; should remove the association between the given symbol and key.
+
+;;; When porting to a new Scheme implementation, you should define the
+;;; procedures listed above, load the expanded version of psyntax.ss
+;;; (psyntax.pp, which should be available whereever you found
+;;; psyntax.ss), and register sc-expand as the current expander (how
+;;; you do this depends upon your implementation of Scheme).  You may
+;;; change the hooks and constructors defined toward the beginning of
+;;; the code below, but to avoid bootstrapping problems, do so only
+;;; after you have a working version of the expander.
+
+;;; Chez Scheme allows the syntactic form (syntax <template>) to be
+;;; abbreviated to #'<template>, just as (quote <datum>) may be
+;;; abbreviated to '<datum>.  The #' syntax makes programs written
+;;; using syntax-case shorter and more readable and draws out the
+;;; intuitive connection between syntax and quote.  If you have access
+;;; to the source code of your Scheme system's reader, you might want
+;;; to implement this extension.
+
+;;; If you find that this code loads or runs slowly, consider
+;;; switching to faster hardware or a faster implementation of
+;;; Scheme.  In Chez Scheme on a 200Mhz Pentium Pro, expanding,
+;;; compiling (with full optimization), and loading this file takes
+;;; between one and two seconds.
+
+;;; In the expander implementation, we sometimes use syntactic abstractions
+;;; when procedural abstractions would suffice.  For example, we define
+;;; top-wrap and top-marked? as
+;;;   (define-syntax top-wrap (identifier-syntax '((top))))
+;;;   (define-syntax top-marked?
+;;;     (syntax-rules ()
+;;;       ((_ w) (memq 'top (wrap-marks w)))))
+;;; rather than
+;;;   (define top-wrap '((top)))
+;;;   (define top-marked?
+;;;     (lambda (w) (memq 'top (wrap-marks w))))
+;;; On ther other hand, we don't do this consistently; we define make-wrap,
+;;; wrap-marks, and wrap-subst simply as
+;;;   (define make-wrap cons)
+;;;   (define wrap-marks car)
+;;;   (define wrap-subst cdr)
+;;; In Chez Scheme, the syntactic and procedural forms of these
+;;; abstractions are equivalent, since the optimizer consistently
+;;; integrates constants and small procedures.  Some Scheme
+;;; implementations, however, may benefit from more consistent use
+;;; of one form or the other.
+
+
+;;; Implementation notes:
+
+;;; "begin" is treated as a splicing construct at top level and at
+;;; the beginning of bodies.  Any sequence of expressions that would
+;;; be allowed where the "begin" occurs is allowed.
+
+;;; "let-syntax" and "letrec-syntax" are also treated as splicing
+;;; constructs, in violation of the R5RS.  A consequence is that let-syntax
+;;; and letrec-syntax do not create local contours, as do let and letrec.
+;;; Although the functionality is greater as it is presently implemented,
+;;; we will probably change it to conform to the R5RS.  modules provide
+;;; similar functionality to nonsplicing letrec-syntax when the latter is
+;;; used as a definition.
+
+;;; Objects with no standard print syntax, including objects containing
+;;; cycles and syntax objects, are allowed in quoted data as long as they
+;;; are contained within a syntax form or produced by datum->syntax-object.
+;;; Such objects are never copied.
+
+;;; When the expander encounters a reference to an identifier that has
+;;; no global or lexical binding, it treats it as a global-variable
+;;; reference.  This allows one to write mutually recursive top-level
+;;; definitions, e.g.:
+;;;
+;;;   (define f (lambda (x) (g x)))
+;;;   (define g (lambda (x) (f x)))
+;;;
+;;; but may not always yield the intended when the variable in question
+;;; is later defined as a keyword.
+
+;;; Top-level variable definitions of syntax keywords are permitted.
+;;; In order to make this work, top-level define not only produces a
+;;; top-level definition in the core language, but also modifies the
+;;; compile-time environment (using $sc-put-cte) to record the fact
+;;; that the identifier is a variable.
+
+;;; Top-level definitions of macro-introduced identifiers are visible
+;;; only in code produced by the macro.  That is, a binding for a
+;;; hidden (generated) identifier is created instead, and subsequent
+;;; references within the macro output are renamed accordingly.  For
+;;; example:
+;;;
+;;; (define-syntax a
+;;;   (syntax-rules ()
+;;;     ((_ var exp)
+;;;      (begin
+;;;        (define secret exp)
+;;;        (define var
+;;;          (lambda ()
+;;;            (set! secret (+ secret 17))
+;;;            secret))))))
+;;; (a x 0)
+;;; (x) => 17
+;;; (x) => 34
+;;; secret => Error: variable secret is not bound
+;;;
+;;; The definition above would fail if the definition for secret
+;;; were placed after the definition for var, since the expander would
+;;; encounter the references to secret before the definition that
+;;; establishes the compile-time map from the identifier secret to
+;;; the generated identifier.
+
+;;; Identifiers and syntax objects are implemented as vectors for
+;;; portability.  As a result, it is possible to "forge" syntax
+;;; objects.
+
+;;; The input to sc-expand may contain "annotations" describing, e.g., the
+;;; source file and character position from where each object was read if
+;;; it was read from a file.  These annotations are handled properly by
+;;; sc-expand only if the annotation? hook (see hooks below) is implemented
+;;; properly and the operators annotation-expression and annotation-stripped
+;;; are supplied.  If annotations are supplied, the proper annotated
+;;; expression is passed to the various output constructors, allowing
+;;; implementations to accurately correlate source and expanded code.
+;;; Contact one of the authors for details if you wish to make use of
+;;; this feature.
+
+;;; Implementation of modules:
+;;;
+;;; The implementation of modules requires that implicit top-level exports
+;;; be listed with the exported macro at some level where both are visible,
+;;; e.g.,
+;;;
+;;;   (module M (alpha (beta b))
+;;;     (module ((alpha a) b)
+;;;       (define-syntax alpha (identifier-syntax a))
+;;;       (define a 'a)
+;;;       (define b 'b))
+;;;     (define-syntax beta (identifier-syntax b)))
+;;;
+;;; Listing of implicit imports is not needed for macros that do not make
+;;; it out to top level, including all macros that are local to a "body".
+;;; (They may be listed in this case, however.)  We need this information
+;;; for top-level modules since a top-level module expands into a letrec
+;;; for non-top-level variables and top-level definitions (assignments) for
+;;; top-level variables.  Because of the general nature of macro
+;;; transformers, we cannot determine the set of implicit exports from the
+;;; transformer code, so without the user's help, we'd have to put all
+;;; variables at top level.
+;;;
+;;; Each such top-level identifier is given a generated name (gensym).
+;;; When a top-level module is imported at top level, a compile-time
+;;; alias is established from the top-level name to the generated name.
+;;; The expander follows these aliases transparently.  When any module is
+;;; imported anywhere other than at top level, the id-var-name of the
+;;; import identifier is set to the id-var-name of the export identifier.
+;;; Since we can't determine the actual labels for identifiers defined in
+;;; top-level modules until we determine which are placed in the letrec
+;;; and which make it to top level, we give each an "indirect" label---a
+;;; pair whose car will eventually contain the actual label.  Import does
+;;; not follow the indirect, but id-var-name does.
+;;;
+;;; All identifiers defined within a local module are folded into the
+;;; letrec created for the enclosing body.  Visibility is controlled in
+;;; this case and for nested top-level modules by introducing a new wrap
+;;; for each module.
+
+
+;;; Bootstrapping:
+
+;;; When changing syntax-object representations, it is necessary to support
+;;; both old and new syntax-object representations in id-var-name.  It
+;;; should be sufficient to redefine syntax-object-expression to work for
+;;; both old and new representations and syntax-object-wrap to return the
+;;; empty-wrap for old representations.
+
+
+;;; The following set of definitions establishes bindings for the
+;;; top-level variables assigned values in the let expression below.
+;;; Uncomment them here and copy them to the front of psyntax.pp if
+;;; required by your system.
+
+; (define $sc-put-cte #f)
+; (define sc-expand #f)
+; (define $make-environment #f)
+; (define environment? #f)
+; (define interaction-environment #f)
+; (define identifier? #f)
+; (define syntax->list #f)
+; (define syntax-object->datum #f)
+; (define datum->syntax-object #f)
+; (define generate-temporaries #f)
+; (define free-identifier=? #f)
+; (define bound-identifier=? #f)
+; (define literal-identifier=? #f)
+; (define syntax-error #f)
+; (define $syntax-dispatch #f)
+
+
+(let ()
+
+(define-syntax when
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (if test (begin e1 e2 ...)))))
+(define-syntax unless
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (when (not test) (begin e1 e2 ...)))))
+(define-syntax define-structure
+  (lambda (x)
+    (define construct-name
+      (lambda (template-identifier . args)
+        (datum->syntax-object
+          template-identifier
+          (string->symbol
+            (apply string-append
+                   (map (lambda (x)
+                          (if (string? x)
+                              x
+                              (symbol->string (syntax-object->datum x))))
+                        args))))))
+    (syntax-case x ()
+      ((_ (name id1 ...))
+       (andmap identifier? (syntax (name id1 ...)))
+       (with-syntax
+         ((constructor (construct-name (syntax name) "make-" (syntax name)))
+          (predicate (construct-name (syntax name) (syntax name) "?"))
+          ((access ...)
+           (map (lambda (x) (construct-name x (syntax name) "-" x))
+                (syntax (id1 ...))))
+          ((assign ...)
+           (map (lambda (x)
+                  (construct-name x "set-" (syntax name) "-" x "!"))
+                (syntax (id1 ...))))
+          (structure-length
+           (fx+ (length (syntax (id1 ...))) 1))
+          ((index ...)
+           (let f ((i 1) (ids (syntax (id1 ...))))
+              (if (null? ids)
+                  '()
+                  (cons i (f (fx+ i 1) (cdr ids)))))))
+         (syntax (begin
+                   (define constructor
+                     (lambda (id1 ...)
+                       (vector 'name id1 ... )))
+                   (define predicate
+                     (lambda (x)
+                       (and (vector? x)
+                            (fx= (vector-length x) structure-length)
+                            (eq? (vector-ref x 0) 'name))))
+                   (define access
+                     (lambda (x)
+                       (vector-ref x index)))
+                   ...
+                   (define assign
+                     (lambda (x update)
+                       (vector-set! x index update)))
+                   ...)))))))
+
+(define-syntax let-values ; impoverished one-clause version
+  (syntax-rules ()
+    ((_ ((formals expr)) form1 form2 ...)
+     (call-with-values (lambda () expr) (lambda formals form1 form2 ...)))))
+
+(define noexpand "noexpand")
+
+(define-structure (syntax-object expression wrap))
+
+;;; hooks to nonportable run-time helpers
+(begin
+;(define-syntax fx+ (identifier-syntax +))
+;(define-syntax fx- (identifier-syntax -))
+;(define-syntax fx= (identifier-syntax =))
+;(define-syntax fx< (identifier-syntax <))
+;(define-syntax fx> (identifier-syntax >))
+;(define-syntax fx<= (identifier-syntax <=))
+;(define-syntax fx>= (identifier-syntax >=))
+
+(define annotation? (lambda (x) #f))
+(define annotation-expression 
+  (lambda (x) (error 'annotation-expression "not yet")))
+(define annotation-stripped 
+  (lambda (x) (error 'annotation-stripped "not yet")))
+
+; top-level-eval-hook is used to create "permanent" code (e.g., top-level
+; transformers), so it might be a good idea to compile it
+(define top-level-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+; local-eval-hook is used to create "temporary" code (e.g., local
+; transformers), so it might be a good idea to interpret it
+(define local-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+(define define-top-level-value-hook
+  (lambda (sym val)
+    (top-level-eval-hook
+      (build-global-definition no-source sym
+        (build-data no-source val)))))
+
+(define error-hook
+  (lambda (who why what)
+    (error who "~a ~s" why what)))
+
+(define-syntax gensym-hook
+  (syntax-rules ()
+    ((_) (gensym))))
+
+;;; AZIZ
+;;; (define put-cte-hook
+;;;   (lambda (symbol val)
+;;;     ($sc-put-cte symbol val '*top*)))
+
+(define put-cte-hook
+  (lambda (symbol val)
+    ($sc-put-cte symbol val '*top*)))
+
+(define get-global-definition-hook
+  (lambda (symbol)
+    (getprop symbol '*sc-expander*)))
+
+(define put-global-definition-hook
+  (lambda (symbol x)
+    (if (not x)
+        (remprop symbol '*sc-expander*)
+        (putprop symbol '*sc-expander* x))))
+
+; if you treat certain bindings (say from environments like ieee or r5rs)
+; read-only, this should return #t for those bindings
+(define read-only-binding?
+  (lambda (symbol)
+    #f))
+
+; should return #f if symbol has no binding for token
+(define get-import-binding
+  (lambda (symbol token)
+    (getprop symbol token)))
+
+; remove binding if x is false
+(define put-import-binding
+  (lambda (symbol token x)
+    (if (not x)
+        (remprop symbol token)
+        (putprop symbol token x))))
+
+;;; generate-id ideally produces globally unique symbols, i.e., symbols
+;;; unique across system runs, to support separate compilation/expansion.
+;;; Use gensym-hook if you do not need to support separate compilation/
+;;; expansion or if your system's gensym creates globally unique
+;;; symbols (as in Chez Scheme).  Otherwise, use the following code
+;;; as a starting point.  session-key should be a unique string for each
+;;; system run to support separate compilation; the default value given
+;;; is satisfactory during initial development only.
+;(define generate-id
+;  (let ((digits "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/:<=>?~_^.+-"))
+;    (let ((base (string-length digits)) (session-key "_"))
+;      (define make-digit (lambda (x) (string-ref digits x)))
+;      (define fmt
+;        (lambda (n)
+;          (let fmt ((n n) (a '()))
+;            (if (< n base)
+;                (list->string (cons (make-digit n) a))
+;                (let ((r (modulo n base)) (rest (quotient n base)))
+;                  (fmt rest (cons (make-digit r) a)))))))
+;      (let ((n -1))
+;        (lambda (name) ; name is #f or a symbol
+;          (set! n (+ n 1))
+;          (string->symbol (string-append session-key (fmt n))))))))
+;;; AZIZ
+(define generate-id
+  (lambda (name)
+    (if name (gensym (symbol->string name)) (gensym))))
+)
+
+
+
+;;; output constructors
+(begin
+(define-syntax build-application
+  (syntax-rules ()
+    ((_ ae fun-exp arg-exps)
+     `(,fun-exp . ,arg-exps))))
+
+(define-syntax build-conditional
+  (syntax-rules ()
+    ((_ ae test-exp then-exp else-exp)
+     `(if ,test-exp ,then-exp ,else-exp))))
+
+(define-syntax build-lexical-reference
+  (syntax-rules ()
+    ((_ type ae var)
+     var)))
+
+(define-syntax build-lexical-assignment
+  (syntax-rules ()
+    ((_ ae var exp)
+     `(set! ,var ,exp))))
+
+;;; AZIZ
+;;; (define-syntax build-global-reference
+;;;   (syntax-rules ()
+;;;     ((_ ae var)
+;;;      var)))
+(define-syntax build-global-reference
+  (syntax-rules ()
+    [(_ ae var)
+     `(top-level-value ',var)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-assignment
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(set! ,var ,exp))))
+(define-syntax build-global-assignment
+  (syntax-rules ()
+    [(_ ae var exp)
+     `(set-top-level-value! ',var ,exp)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-definition
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(define ,var ,exp))))
+(define-syntax build-global-definition
+  (syntax-rules ()
+    [(_ ae var exp)
+     (build-global-assignment ae var exp)]))
+
+
+(define-syntax build-cte-install
+ ; should build a call that has the same effect as calling put-cte-hook
+  (syntax-rules ()
+    ((_ sym exp token) 
+     `(#%$sc-put-cte ',sym ,exp ',token))))
+
+(define-syntax build-visit-only
+ ; should mark the result as "visit only" for compile-file
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+(define-syntax build-revisit-only
+ ; should mark the result as "revisit only" for compile-file,
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+;;; AZIZ
+;;; (define-syntax build-lambda
+;;;   (syntax-rules ()
+;;;     ((_ ae vars exp)
+;;;      `(lambda ,vars ,exp))))
+(define-syntax build-lambda
+  (syntax-rules ()
+    [(_ ae vars exp)
+     `(case-lambda [,vars ,exp])]))
+
+(define build-case-lambda
+  (lambda (ae vars* exp*)
+    `(case-lambda . ,(map list vars* exp*))))
+
+;;; AZIZ
+;;; (define built-lambda?
+;;;   (lambda (x)
+;;;     (and (pair? x) (eq? (car x) 'lambda))))
+(define built-lambda?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'case-lambda))))
+
+;;; AZIZ
+;;; (define-syntax build-primref
+;;;   (syntax-rules ()
+;;;     ((_ ae name) name)
+;;;     ((_ ae level name) name)))
+(define-syntax build-primref
+  (syntax-rules ()
+    [(_ ae name)       `(|#primitive| ,name)]
+    [(_ ae level name) `(|#primitive| ,name)]))
+
+
+;;; AZIZ
+(define-syntax build-foreign-call
+  (syntax-rules ()
+    [(_ ae name arg*) `(foreign-call ,name . ,arg*)]))
+(define-syntax build-$apply
+  (syntax-rules ()
+    [(_ ae proc arg*) `($apply ,proc . ,arg*)]))
+
+(define-syntax build-data
+  (syntax-rules ()
+    ((_ ae exp) `',exp)))
+
+(define build-sequence
+  (lambda (ae exps)
+    (let loop ((exps exps))
+      (if (null? (cdr exps))
+          (car exps)
+         ; weed out leading void calls, assuming ordinary list representation
+          (if (equal? (car exps) '(#%void))
+              (loop (cdr exps))
+              `(begin ,@exps))))))
+
+(define build-letrec
+  (lambda (ae vars val-exps body-exp)
+    (if (null? vars)
+        body-exp
+        `(letrec ,(map list vars val-exps) ,body-exp))))
+
+
+(define build-body
+  (lambda (ae vars val-exps body-exp)
+    (build-letrec ae vars val-exps body-exp)))
+
+(define build-top-module
+ ; each type is either global (exported) or local (not exported)
+ ; we produce global definitions and assignments for globals and
+ ; letrec bindings for locals.  if you don't need the definitions,
+ ; (just assignments) you can eliminate them.  if you wish to
+ ; have your module definitions ordered from left-to-right (ala
+ ; letrec*), you can replace the global var-exps with dummy vars
+ ; and global val-exps with global assignments, and produce a letrec*
+ ; in place of a letrec.
+  (lambda (ae types vars val-exps body-exp)
+    (let-values (((vars defns sets)
+                  (let f ((types types) (vars vars))
+                    (if (null? types)
+                        (values '() '() '())
+                        (let ((var (car vars)))
+                          (let-values (((vars defns sets) (f (cdr types) (cdr vars))))
+                            (if (eq? (car types) 'global)
+                                (let ((x (build-lexical-var no-source var)))
+                                  (values
+                                    (cons x vars)
+                                    (cons (build-global-definition no-source var (chi-void)) defns)
+                                    (cons (build-global-assignment no-source var (build-lexical-reference 'value no-source x)) sets)))
+                                (values (cons var vars) defns sets))))))))
+      (if (null? defns)
+          (build-letrec ae vars val-exps body-exp)
+          (build-sequence no-source
+            (append defns
+              (list
+                (build-letrec ae vars val-exps
+                  (build-sequence no-source (append sets (list body-exp)))))))))))
+
+(define-syntax build-lexical-var
+  (syntax-rules ()
+    ((_ ae id) (gensym))))
+
+(define-syntax lexical-var? gensym?)
+
+(define-syntax self-evaluating?
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (or (boolean? x) (fixnum? x) (string? x) (char? x) (null? x))))))
+)
+
+(define-syntax unannotate
+  (syntax-rules ()
+    ((_ x)
+     (let ((e x))
+       (if (annotation? e)
+           (annotation-expression e)
+           e)))))
+
+(define-syntax no-source (identifier-syntax #f))
+
+(define-syntax arg-check
+  (syntax-rules ()
+    ((_ pred? e who)
+     (let ((x e))
+       (if (not (pred? x)) (error-hook who "invalid argument" x))))))
+
+;;; compile-time environments
+
+;;; wrap and environment comprise two level mapping.
+;;;   wrap : id --> label
+;;;   env : label --> <element>
+
+;;; environments are represented in two parts: a lexical part and a global
+;;; part.  The lexical part is a simple list of associations from labels
+;;; to bindings.  The global part is implemented by
+;;; {put,get}-global-definition-hook and associates symbols with
+;;; bindings.
+
+;;; global (assumed global variable) and displaced-lexical (see below)
+;;; do not show up in any environment; instead, they are fabricated by
+;;; lookup when it finds no other bindings.
+
+;;; <environment>              ::= ((<label> . <binding>)*)
+
+;;; identifier bindings include a type and a value
+
+;;; <binding> ::= <procedure>                     macro keyword
+;;;               (macro . <procedure>)           macro keyword
+;;;               (deferred . <thunk>)            macro keyword w/lazily evaluated transformer
+;;;               (macro! . <procedure>)          extended identifier macro keyword
+;;;               (core . <procedure>)            core keyword
+;;;               (begin)                         begin keyword
+;;;               (define)                        define keyword
+;;;               (define-syntax)                 define-syntax keyword
+;;;               (local-syntax . <boolean>)      let-syntax (#f)/letrec-syntax (#t) keyword
+;;;               (eval-when)                     eval-when keyword
+;;;               (set!)                          set! keyword
+;;;               (meta)                          meta keyword
+;;;               ($module-key)                   $module keyword
+;;;               ($import)                       $import keyword
+;;;               ($module . <interface>)         modules
+;;;               (syntax . (<var> . <level>))    pattern variables
+;;;               (global . <symbol>)             assumed global variable
+;;;               (meta-variable . <symbol>)      meta variable
+;;;               (lexical . <var>)               lexical variables
+;;;               (displaced-lexical . #f)        id-var-name not found in store
+;;; <level>   ::= <nonnegative integer>
+;;; <var>     ::= variable returned by build-lexical-var
+
+;;; a macro is a user-defined syntactic-form.  a core is a system-defined
+;;; syntactic form.  begin, define, define-syntax, let-syntax, letrec-syntax,
+;;; eval-when, and meta are treated specially since they are sensitive to
+;;; whether the form is at top-level and can denote valid internal
+;;; definitions.
+
+;;; a pattern variable is a variable introduced by syntax-case and can
+;;; be referenced only within a syntax form.
+
+;;; any identifier for which no top-level syntax definition or local
+;;; binding of any kind has been seen is assumed to be a global
+;;; variable.
+
+;;; a lexical variable is a lambda- or letrec-bound variable.
+
+;;; a displaced-lexical identifier is a lexical identifier removed from
+;;; it's scope by the return of a syntax object containing the identifier.
+;;; a displaced lexical can also appear when a letrec-syntax-bound
+;;; keyword is referenced on the rhs of one of the letrec-syntax clauses.
+;;; a displaced lexical should never occur with properly written macros.
+
+(define sanitize-binding
+  (lambda (b)
+    (cond
+      ((procedure? b) (make-binding 'macro b))
+      ((binding? b)
+       (and (case (binding-type b)
+              ((core macro macro! deferred)
+               (and (procedure? (binding-value b))))
+              (($module) (interface? (binding-value b)))
+              ((lexical) (lexical-var? (binding-value b)))
+              ((global meta-variable) (symbol? (binding-value b)))
+              ((syntax) (let ((x (binding-value b)))
+                          (and (pair? x)
+                               (lexical-var? (car x))
+                               (let ((n (cdr x)))
+                                 (and (fixnum? n) (fx>= n 0))))))
+              ((begin define define-syntax set! $module-key $import eval-when meta) (null? (binding-value b)))
+              ((local-syntax) (boolean? (binding-value b)))
+              ((displaced-lexical) (eq? (binding-value b) #f))
+              (else #t))
+            b))
+      (else #f))))
+
+(define-syntax make-binding
+  (syntax-rules (quote)
+    ((_ 'type #f) '(type . #f))
+    ((_ type value) (cons type value))))
+
+(define binding-type car)
+(define binding-value cdr)
+(define set-binding-type! set-car!)
+(define set-binding-value! set-cdr!)
+(define binding? (lambda (x) (and (pair? x) (symbol? (car x)))))
+
+(define-syntax null-env (identifier-syntax '()))
+
+(define extend-env
+  (lambda (label binding r)
+    (cons (cons label binding) r)))
+
+(define extend-env*
+  (lambda (labels bindings r)
+    (if (null? labels)
+        r
+        (extend-env* (cdr labels) (cdr bindings)
+          (extend-env (car labels) (car bindings) r)))))
+
+(define extend-var-env*
+  ; variant of extend-env* that forms "lexical" binding
+  (lambda (labels vars r)
+    (if (null? labels)
+        r
+        (extend-var-env* (cdr labels) (cdr vars)
+          (extend-env (car labels) (make-binding 'lexical (car vars)) r)))))
+
+(define (displaced-lexical? id r)
+  (let ((n (id-var-name id empty-wrap)))
+    (and n
+         (let ((b (lookup n r)))
+           (eq? (binding-type b) 'displaced-lexical)))))
+
+(define displaced-lexical-error
+  (lambda (id)
+    (syntax-error id
+      (if (id-var-name id empty-wrap)
+          "identifier out of context"
+          "identifier not visible"))))
+
+(define lookup*
+  ; x may be a label or a symbol
+  ; although symbols are usually global, we check the environment first
+  ; anyway because a temporary binding may have been established by
+  ; fluid-let-syntax
+  (lambda (x r)
+    (cond
+      ((assq x r) => cdr)
+      ((symbol? x)
+       (or (get-global-definition-hook x) (make-binding 'global x)))
+      (else (make-binding 'displaced-lexical #f)))))
+
+(define lookup
+  (lambda (x r)
+    (define whack-binding!
+      (lambda (b *b)
+        (set-binding-type! b (binding-type *b))
+        (set-binding-value! b (binding-value *b))))
+    (let ((b (lookup* x r)))
+      (when (eq? (binding-type b) 'deferred)
+        (whack-binding! b (make-transformer-binding ((binding-value b)))))
+      b)))
+
+(define make-transformer-binding
+  (lambda (b)
+    (or (sanitize-binding b)
+        (syntax-error b "invalid transformer"))))
+
+(define defer-or-eval-transformer
+  (lambda (eval x)
+    (if (built-lambda? x)
+        (make-binding 'deferred (lambda () (eval x)))
+        (make-transformer-binding (eval x)))))
+
+(define global-extend
+  (lambda (type sym val)
+    (put-cte-hook sym (make-binding type val))))
+
+
+;;; Conceptually, identifiers are always syntax objects.  Internally,
+;;; however, the wrap is sometimes maintained separately (a source of
+;;; efficiency and confusion), so that symbols are also considered
+;;; identifiers by id?.  Externally, they are always wrapped.
+
+(define nonsymbol-id?
+  (lambda (x)
+    (and (syntax-object? x)
+         (symbol? (unannotate (syntax-object-expression x))))))
+
+(define id?
+  (lambda (x)
+    (cond
+      ((symbol? x) #t)
+      ((syntax-object? x) (symbol? (unannotate (syntax-object-expression x))))
+      ((annotation? x) (symbol? (annotation-expression x)))
+      (else #f))))
+
+(define-syntax id-sym-name
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (unannotate (if (syntax-object? x) (syntax-object-expression x) x))))))
+
+(define id-marks
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-marks (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-subst
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-subst (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-sym-name&marks
+  (lambda (x w)
+    (if (syntax-object? x)
+        (values
+          (unannotate (syntax-object-expression x))
+          (join-marks (wrap-marks w) (wrap-marks (syntax-object-wrap x))))
+        (values (unannotate x) (wrap-marks w)))))
+
+;;; syntax object wraps
+
+;;;         <wrap>     ::= ((<mark> ...) . (<subst> ...))
+;;;        <subst>     ::= <ribcage> | <shift>
+;;;      <ribcage>     ::= #((<ex-symname> ...) (<mark> ...) (<label> ...)) ; extensible, for chi-internal/external
+;;;                      | #(#(<symname> ...) #(<mark> ...) #(<label> ...)) ; nonextensible
+;;;   <ex-symname>     ::= <symname> | <import token> | <barrier>
+;;;        <shift>     ::= shift
+;;;      <barrier>     ::= #f                                               ; inserted by import-only
+;;; <import interface> ::= #<import-interface interface new-marks>
+;;;        <token>     ::= <generated id>
+
+(define make-wrap cons)
+(define wrap-marks car)
+(define wrap-subst cdr)
+
+
+(define-syntax empty-wrap (identifier-syntax '(())))
+
+(define-syntax top-wrap (identifier-syntax '((top))))
+
+(define-syntax top-marked?
+  (syntax-rules ()
+    ((_ w) (memq 'top (wrap-marks w)))))
+
+(define-syntax only-top-marked?
+  (syntax-rules ()
+    ((_ id) (same-marks? (wrap-marks (syntax-object-wrap id)) (wrap-marks top-wrap)))))
+
+;;; labels
+
+;;; simple labels must be comparable with "eq?" and distinct from symbols
+;;; and pairs.
+
+;;; indirect labels, which are implemented as pairs, are used to support
+;;; import aliasing for identifiers exported (explictly or implicitly) from
+;;; top-level modules.  chi-external creates an indirect label for each
+;;; defined identifier, import causes the pair to be shared with aliases it
+;;; establishes, and chi-top-module whacks the pair to hold the top-level
+;;; identifier name (symbol) if the id is to be placed at top level, before
+;;; expanding the right-hand sides of the definitions in the module.
+
+(module (gen-indirect-label indirect-label? get-indirect-label set-indirect-label!)
+  (define-structure (indirect-label label))
+  (define gen-indirect-label
+    (lambda ()
+      (make-indirect-label (gen-label))))
+  (define get-indirect-label (lambda (x) (indirect-label-label x)))
+  (define set-indirect-label! (lambda (x v) (set-indirect-label-label! x v))))
+
+(define gen-label
+  (lambda () (string #\i)))
+(define label?
+  (lambda (x)
+    (or (string? x) ; normal lexical labels
+        (symbol? x) ; global labels (symbolic names)
+        (indirect-label? x))))
+
+(define gen-labels
+  (lambda (ls)
+    (if (null? ls)
+        '()
+        (cons (gen-label) (gen-labels (cdr ls))))))
+
+(define-structure (ribcage symnames marks labels))
+(define-structure (top-ribcage key mutable?))
+(define-structure (import-interface interface new-marks))
+(define-structure (env top-ribcage wrap))
+
+;;; Marks must be comparable with "eq?" and distinct from pairs and
+;;; the symbol top.  We do not use integers so that marks will remain
+;;; unique even across file compiles.
+
+(define-syntax the-anti-mark (identifier-syntax #f))
+
+(define anti-mark
+  (lambda (w)
+    (make-wrap (cons the-anti-mark (wrap-marks w))
+               (cons 'shift (wrap-subst w)))))
+
+(define-syntax new-mark
+  (syntax-rules ()
+    ((_) (string #\m))))
+
+(define barrier-marker #f)
+
+;;; make-empty-ribcage and extend-ribcage maintain list-based ribcages for
+;;; internal definitions, in which the ribcages are built incrementally
+(define-syntax make-empty-ribcage
+  (syntax-rules ()
+    ((_) (make-ribcage '() '() '()))))
+
+(define extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks (syntax-object-wrap id))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define import-extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage new-marks id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (join-marks new-marks (wrap-marks (syntax-object-wrap id)))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define extend-ribcage-barrier!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage killer-id)
+    (extend-ribcage-barrier-help! ribcage (syntax-object-wrap killer-id))))
+
+(define extend-ribcage-barrier-help!
+  (lambda (ribcage wrap)
+    (set-ribcage-symnames! ribcage
+      (cons barrier-marker (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks wrap) (ribcage-marks ribcage)))))
+
+(define extend-ribcage-subst!
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage import-iface)
+    (set-ribcage-symnames! ribcage
+      (cons import-iface (ribcage-symnames ribcage)))))
+
+(define lookup-import-binding-name
+  (lambda (sym marks token new-marks)
+    (let ((new (get-import-binding sym token)))
+      (and new
+           (let f ((new new))
+             (cond
+               ((pair? new) (or (f (car new)) (f (cdr new))))
+               ((symbol? new)
+                (and (same-marks? marks (join-marks new-marks (wrap-marks top-wrap))) new))
+               ((same-marks? marks (join-marks new-marks (wrap-marks (syntax-object-wrap new)))) new)
+               (else #f)))))))
+  
+(define store-import-binding
+  (lambda (id token new-marks)
+    (define cons-id
+      (lambda (id x)
+        (if (not x) id (cons id x))))
+    (define weed ; remove existing binding for id, if any
+      (lambda (marks x)
+        (if (pair? x)
+            (if (same-marks? (id-marks (car x)) marks)
+                (weed marks (cdr x))
+                (cons-id (car x) (weed marks (cdr x))))
+            (and x (not (same-marks? (id-marks x) marks)) x))))
+    (let ((id (if (null? new-marks)
+                  id
+                  (make-syntax-object (id-sym-name id)
+                    (make-wrap
+                      (join-marks new-marks (id-marks id))
+                      (id-subst id))))))
+      (let ((sym (id-sym-name id)))
+       ; no need to record bindings mapping symbol to self, since this   
+       ; assumed by default.
+        (unless (eq? id sym)
+          (let ((marks (id-marks id)))
+            (let ((x (weed marks (get-import-binding sym token))))
+              (put-import-binding sym token
+                (cons-id
+                  (if (same-marks? marks (wrap-marks top-wrap))
+                     ; need full id only if more than top-marked.
+                      (resolved-id-var-name id)
+                      id)
+                  x)))))))))
+
+;;; make-binding-wrap creates vector-based ribcages
+(define make-binding-wrap
+  (lambda (ids labels w)
+    (if (null? ids)
+        w
+        (make-wrap
+          (wrap-marks w)
+          (cons
+            (let ((labelvec (list->vector labels)))
+              (let ((n (vector-length labelvec)))
+                (let ((symnamevec (make-vector n)) (marksvec (make-vector n)))
+                  (let f ((ids ids) (i 0))
+                    (unless (null? ids)
+                      (let-values (((symname marks) (id-sym-name&marks (car ids) w)))
+                        (vector-set! symnamevec i symname)
+                        (vector-set! marksvec i marks)
+                        (f (cdr ids) (fx+ i 1)))))
+                  (make-ribcage symnamevec marksvec labelvec))))
+            (wrap-subst w))))))
+
+;;; resolved ids contain no unnecessary substitutions or marks.  they are
+;;; used essentially as indirects or aliases in modules interfaces.
+(define make-resolved-id
+  (lambda (fromsym marks tosym)
+    (make-syntax-object fromsym
+      (make-wrap marks
+        (list (make-ribcage (vector fromsym) (vector marks) (vector tosym)))))))
+
+(define id->resolved-id
+  (lambda (id)
+    (let-values (((tosym marks) (id-var-name&marks id empty-wrap)))
+      (unless tosym
+        (syntax-error id "identifier not visible for export"))
+      (make-resolved-id (id-sym-name id) marks tosym))))
+
+(define resolved-id-var-name
+  (lambda (id)
+    (vector-ref
+      (ribcage-labels (car (wrap-subst (syntax-object-wrap id))))
+      0)))
+
+;;; Scheme's append should not copy the first argument if the second is
+;;; nil, but it does, so we define a smart version here.
+(define smart-append
+  (lambda (m1 m2)
+    (if (null? m2)
+        m1
+        (append m1 m2))))
+
+(define join-wraps
+  (lambda (w1 w2)
+    (let ((m1 (wrap-marks w1)) (s1 (wrap-subst w1)))
+      (if (null? m1)
+          (if (null? s1)
+              w2
+              (make-wrap
+                (wrap-marks w2)
+                (join-subst s1 (wrap-subst w2))))
+          (make-wrap
+            (join-marks m1 (wrap-marks w2))
+            (join-subst s1 (wrap-subst w2)))))))
+
+(define join-marks
+  (lambda (m1 m2)
+    (smart-append m1 m2)))
+
+(define join-subst
+  (lambda (s1 s2)
+    (smart-append s1 s2)))
+
+(define same-marks?
+  (lambda (x y)
+    (or (eq? x y)
+        (and (not (null? x))
+             (not (null? y))
+             (eq? (car x) (car y))
+             (same-marks? (cdr x) (cdr y))))))
+
+(define diff-marks
+  (lambda (m1 m2)
+    (let ((n1 (length m1)) (n2 (length m2)))
+      (let f ((n1 n1) (m1 m1))
+        (cond
+          ((fx> n1 n2) (cons (car m1) (f (fx- n1 1) (cdr m1))))
+          ((equal? m1 m2) '())
+          (else (error 'sc-expand
+                  "internal error in diff-marks: ~s is not a tail of ~s"
+                  m1 m2)))))))
+
+(module (top-id-bound-var-name top-id-free-var-name)
+  ;; top-id-bound-var-name is used to look up or establish new top-level
+  ;; substitutions, while top-id-free-var-name is used to look up existing
+  ;; (possibly implicit) substitutions.  Implicit substitutions exist
+  ;; for top-marked names in all environments, but we represent them
+  ;; explicitly only on demand.
+  ;;
+  ;; In both cases, we first look for an existing substitution for sym
+  ;; and the given marks.  If we find one, we return it.  Otherwise, we
+  ;; extend the appropriate top-level environment
+  ;;
+  ;; For top-id-bound-var-name, we extend the environment with a substition
+  ;; keyed by the given marks, so that top-level definitions introduced by
+  ;; a macro are distinct from other top-level definitions for the same
+  ;; name.  For example, if macros a and b both introduce definitions and
+  ;; bound references to identifier x, the two x's should be different,
+  ;; i.e., keyed by their own marks.
+  ;;
+  ;; For top-id-free-var-name, we extend the environment with a substition
+  ;; keyed by the top marks, since top-level free identifier references
+  ;; should refer to the existing implicit (top-marked) substitution.  For
+  ;; example, if macros a and b both introduce free references to identifier
+  ;; x, they should both refer to the same (global, unmarked) x.
+  ;;
+ ;; If the environment is *top*, we map a symbol to itself
+
+ (define leave-implicit? (lambda (token) (eq? token '*top*)))
+
+  (define new-binding
+    (lambda (sym marks token)
+      (let ((loc (if (and (leave-implicit? token)
+                          (same-marks? marks (wrap-marks top-wrap)))
+                     sym
+                     (generate-id sym))))
+        (let ((id (make-resolved-id sym marks loc)))
+          (store-import-binding id token '())
+          (values loc id)))))
+
+  (define top-id-bound-var-name
+   ; should be called only when top-ribcage is mutable
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id)
+             (if (symbol? id) ; symbol iff marks == (wrap-marks top-wrap)
+                 (if (read-only-binding? id)
+                     (new-binding sym marks token)
+                     (values id (make-resolved-id sym marks id)))
+                 (values (resolved-id-var-name id) id))))
+          (else (new-binding sym marks token))))))
+
+  (define top-id-free-var-name
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id) (if (symbol? id) id (resolved-id-var-name id))))
+          ((and (top-ribcage-mutable? top-ribcage)
+                (same-marks? marks (wrap-marks top-wrap)))
+           (let-values (((sym id) (new-binding sym (wrap-marks top-wrap) token)))
+             sym))
+          (else #f))))))
+
+(define id-var-name-loc&marks
+  (lambda (id w)
+    (define search
+      (lambda (sym subst marks)
+        (if (null? subst)
+            (values #f marks)
+            (let ((fst (car subst)))
+               (cond
+                 ((eq? fst 'shift) (search sym (cdr subst) (cdr marks)))
+                 ((ribcage? fst)
+                  (let ((symnames (ribcage-symnames fst)))
+                    (if (vector? symnames)
+                        (search-vector-rib sym subst marks symnames fst)
+                        (search-list-rib sym subst marks symnames fst))))
+                 ((top-ribcage? fst)
+                  (cond
+                    ((top-id-free-var-name sym marks fst) =>
+                     (lambda (var-name) (values var-name marks)))
+                    (else (search sym (cdr subst) marks))))
+                 (else
+                  (error 'sc-expand
+                    "internal error in id-var-name-loc&marks: improper subst ~s"
+                    subst)))))))
+    (define search-list-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let f ((symnames symnames) (i 0))
+          (if (null? symnames)
+              (search sym (cdr subst) marks)
+              (let ((x (car symnames)))
+                (cond
+                  ((and (eq? x sym)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values (list-ref (ribcage-labels ribcage) i) marks))
+                  ((import-interface? x)
+                   (let ((iface (import-interface-interface x))
+                         (new-marks (import-interface-new-marks x)))
+                     (cond
+                       ((interface-token iface) =>
+                        (lambda (token)
+                          (cond
+                            ((lookup-import-binding-name sym marks token new-marks) =>
+                             (lambda (id)
+                               (values
+                                 (if (symbol? id) id (resolved-id-var-name id))
+                                 marks)))
+                            (else (f (cdr symnames) i)))))
+                       (else
+                        (let* ((ie (interface-exports iface))
+                               (n (vector-length ie)))
+                          (let g ((j 0))
+                            (if (fx= j n)
+                                (f (cdr symnames) i)
+                                (let ((id (vector-ref ie j)))
+                                  (let ((id.sym (id-sym-name id))
+                                        (id.marks (join-marks new-marks (id-marks id))))
+                                    (if (help-bound-id=? id.sym id.marks sym marks)
+                                        (values (lookup-import-label id) marks)
+                                        (g (fx+ j 1))))))))))))
+                  ((and (eq? x barrier-marker)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values #f marks))
+                  (else (f (cdr symnames) (fx+ i 1)))))))))
+    (define search-vector-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let ((n (vector-length symnames)))
+          (let f ((i 0))
+            (cond
+              ((fx= i n) (search sym (cdr subst) marks))
+              ((and (eq? (vector-ref symnames i) sym)
+                    (same-marks? marks (vector-ref (ribcage-marks ribcage) i)))
+               (values (vector-ref (ribcage-labels ribcage) i) marks))
+              (else (f (fx+ i 1))))))))
+    (cond
+      ((symbol? id) (search id (wrap-subst w) (wrap-marks w)))
+      ((syntax-object? id)
+       (let ((sym (unannotate (syntax-object-expression id)))
+             (w1 (syntax-object-wrap id)))
+         (let-values (((name marks) (search sym (wrap-subst w)
+                                      (join-marks
+                                        (wrap-marks w)
+                                        (wrap-marks w1)))))
+           (if name
+               (values name marks)
+               (search sym (wrap-subst w1) marks)))))
+      ((annotation? id) (search (unannotate id) (wrap-subst w) (wrap-marks w)))
+      (else (error-hook 'id-var-name "invalid id" id)))))
+
+(define id-var-name&marks
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (values (if (indirect-label? label) (get-indirect-label label) label) marks))))
+
+(define id-var-name-loc
+ ; this version doesn't follow indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      label)))
+
+(define id-var-name
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (if (indirect-label? label) (get-indirect-label label) label))))
+
+;;; free-id=? must be passed fully wrapped ids since (free-id=? x y)
+;;; may be true even if (free-id=? (wrap x w) (wrap y w)) is not.
+
+(define free-id=?
+  (lambda (i j)
+    (and (eq? (id-sym-name i) (id-sym-name j)) ; accelerator
+         (eq? (id-var-name i empty-wrap) (id-var-name j empty-wrap)))))
+
+(define literal-id=?
+  (lambda (id literal)
+    (and (eq? (id-sym-name id) (id-sym-name literal))
+         (let ((n-id (id-var-name id empty-wrap))
+               (n-literal (id-var-name literal empty-wrap)))
+           (or (eq? n-id n-literal)
+               (and (or (not n-id) (symbol? n-id))
+                    (or (not n-literal) (symbol? n-literal))))))))
+
+;;; bound-id=? may be passed unwrapped (or partially wrapped) ids as
+;;; long as the missing portion of the wrap is common to both of the ids
+;;; since (bound-id=? x y) iff (bound-id=? (wrap x w) (wrap y w))
+
+(define help-bound-id=?
+  (lambda (i.sym i.marks j.sym j.marks)
+    (and (eq? i.sym j.sym)
+         (same-marks? i.marks j.marks))))
+   
+(define bound-id=?
+  (lambda (i j)
+    (help-bound-id=? (id-sym-name i) (id-marks i) (id-sym-name j) (id-marks j))))
+
+;;; "valid-bound-ids?" returns #t if it receives a list of distinct ids.
+;;; valid-bound-ids? may be passed unwrapped (or partially wrapped) ids
+;;; as long as the missing portion of the wrap is common to all of the
+;;; ids.
+
+(define valid-bound-ids?
+  (lambda (ids)
+     (and (let all-ids? ((ids ids))
+            (or (null? ids)
+                (and (id? (car ids))
+                     (all-ids? (cdr ids)))))
+          (distinct-bound-ids? ids))))
+
+;;; distinct-bound-ids? expects a list of ids and returns #t if there are
+;;; no duplicates.  It is quadratic on the length of the id list; long
+;;; lists could be sorted to make it more efficient.  distinct-bound-ids?
+;;; may be passed unwrapped (or partially wrapped) ids as long as the
+;;; missing portion of the wrap is common to all of the ids.
+
+(define distinct-bound-ids?
+  (lambda (ids)
+    (let distinct? ((ids ids))
+      (or (null? ids)
+          (and (not (bound-id-member? (car ids) (cdr ids)))
+               (distinct? (cdr ids)))))))
+
+(define invalid-ids-error
+ ; find first bad one and complain about it
+  (lambda (ids exp class)
+    (let find ((ids ids) (gooduns '()))
+      (if (null? ids)
+          (syntax-error exp) ; shouldn't happen
+          (if (id? (car ids))
+              (if (bound-id-member? (car ids) gooduns)
+                  (syntax-error (car ids) "duplicate " class)
+                  (find (cdr ids) (cons (car ids) gooduns)))
+              (syntax-error (car ids) "invalid " class))))))
+
+(define bound-id-member?
+   (lambda (x list)
+      (and (not (null? list))
+           (or (bound-id=? x (car list))
+               (bound-id-member? x (cdr list))))))
+
+;;; wrapping expressions and identifiers
+
+(define wrap
+  (lambda (x w)
+    (cond
+      ((and (null? (wrap-marks w)) (null? (wrap-subst w))) x)
+      ((syntax-object? x)
+       (make-syntax-object
+         (syntax-object-expression x)
+         (join-wraps w (syntax-object-wrap x))))
+      ((null? x) x)
+      (else (make-syntax-object x w)))))
+
+(define source-wrap
+  (lambda (x w ae)
+    (wrap (if (annotation? ae)
+              (begin
+                (unless (eq? (annotation-expression ae) x)
+                  (error 'sc-expand "internal error in source-wrap: ae/x mismatch"))
+                ae)
+              x)
+          w)))
+
+;;; expanding
+
+(define chi-when-list
+  (lambda (when-list w)
+    ; when-list is syntax'd version of list of situations
+    (map (lambda (x)
+           (cond
+             ((literal-id=? x (syntax compile)) 'compile)
+             ((literal-id=? x (syntax load)) 'load)
+             ((literal-id=? x (syntax visit)) 'visit)
+             ((literal-id=? x (syntax revisit)) 'revisit)
+             ((literal-id=? x (syntax eval)) 'eval)
+             (else (syntax-error (wrap x w) "invalid eval-when situation"))))
+         when-list)))
+
+;;; syntax-type returns five values: type, value, e, w, and ae.  The first
+;;; two are described in the table below.
+;;;
+;;;    type                   value         explanation
+;;;    -------------------------------------------------------------------
+;;;    alias                  none          alias keyword
+;;;    alias-form             none          alias expression
+;;;    begin                  none          begin keyword
+;;;    begin-form             none          begin expression
+;;;    call                   none          any other call
+;;;    constant               none          self-evaluating datum
+;;;    core                   procedure     core form (including singleton)
+;;;    define                 none          define keyword
+;;;    define-form            none          variable definition
+;;;    define-syntax          none          define-syntax keyword
+;;;    define-syntax-form     none          syntax definition
+;;;    displaced-lexical      none          displaced lexical identifier
+;;;    eval-when              none          eval-when keyword
+;;;    eval-when-form         none          eval-when form
+;;;    global                 name          global variable reference
+;;;    $import                none          $import keyword
+;;;    $import-form           none          $import form
+;;;    lexical                name          lexical variable reference
+;;;    lexical-call           name          call to lexical variable
+;;;    local-syntax           rec?          letrec-syntax/let-syntax keyword
+;;;    local-syntax-form      rec?          syntax definition
+;;;    meta                   none          meta keyword
+;;;    meta-form              none          meta form
+;;;    meta-variable          name          meta variable
+;;;    $module                none          $module keyword
+;;;    $module-form           none          $module definition
+;;;    syntax                 level         pattern variable
+;;;    other                  none          anything else
+;;;
+;;; For all forms, e is the form, w is the wrap for e. and ae is the
+;;; (possibly) source-annotated form.
+;;;
+;;; syntax-type expands macros and unwraps as necessary to get to
+;;; one of the forms above.
+
+(define syntax-type
+  (lambda (e r w ae rib)
+    (cond
+      ((symbol? e)
+       (let* ((n (id-var-name e w))
+              (b (lookup n r))
+              (type (binding-type b)))
+         (case type
+           ((macro macro!) (syntax-type (chi-macro (binding-value b) e r w ae rib) r empty-wrap #f rib))
+           (else (values type (binding-value b) e w ae)))))
+      ((pair? e)
+       (let ((first (car e)))
+         (if (id? first)
+             (let* ((n (id-var-name first w))
+                    (b (lookup n r))
+                    (type (binding-type b)))
+               (case type
+                 ((lexical) (values 'lexical-call (binding-value b) e w ae))
+                 ((macro macro!)
+                  (syntax-type (chi-macro (binding-value b) e r w ae rib)
+                    r empty-wrap #f rib))
+                 ((core) (values type (binding-value b) e w ae))
+                 ((begin) (values 'begin-form #f e w ae))
+                 ((alias) (values 'alias-form #f e w ae))
+                 ((define) (values 'define-form #f e w ae))
+                 ((define-syntax) (values 'define-syntax-form #f e w ae))
+                 ((set!) (chi-set! e r w ae rib))
+                 (($module-key) (values '$module-form #f e w ae))
+                 (($import) (values '$import-form #f e w ae))
+                 ((eval-when) (values 'eval-when-form #f e w ae))
+                 ((meta) (values 'meta-form #f e w ae))
+                 ((local-syntax)
+                  (values 'local-syntax-form (binding-value b) e w ae))
+                 (else (values 'call #f e w ae))))
+             (values 'call #f e w ae))))
+      ((syntax-object? e)
+       (syntax-type (syntax-object-expression e)
+                    r
+                    (join-wraps w (syntax-object-wrap e))
+                    #f rib))
+      ((annotation? e)
+       (syntax-type (annotation-expression e) r w e rib))
+      ((self-evaluating? e) (values 'constant #f e w ae))
+      (else (values 'other #f e w ae)))))
+
+(define chi-top*
+  (lambda (e r w ctem rtem meta? top-ribcage)
+    (let ((meta-residuals '()))
+      (define meta-residualize!
+        (lambda (x)
+          (set! meta-residuals
+            (cons x meta-residuals))))
+      (let ((e (chi-top e r w ctem rtem meta? top-ribcage meta-residualize! #f)))
+        (build-sequence no-source
+          (reverse (cons e meta-residuals)))))))
+
+(define chi-top-sequence
+  (lambda (body r w ae ctem rtem meta? ribcage meta-residualize!)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi-top (car body) r w ctem rtem meta? ribcage meta-residualize! #f)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi-top
+  (lambda (e r w ctem rtem meta? top-ribcage meta-residualize! meta-seen?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source top-ribcage)))
+      (case type
+        ((begin-form)
+         (let ((forms (parse-begin e w ae #t)))
+           (if (null? forms)
+               (chi-void)
+               (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!))))
+        ((local-syntax-form)
+         (let-values (((forms r mr w ae) (chi-local-syntax value e r r w ae)))
+          ; mr should be same as r here
+           (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))
+        ((eval-when-form)
+         (let-values (((when-list forms) (parse-eval-when e w ae)))
+           (let ((ctem (update-mode-set when-list ctem))
+                 (rtem (update-mode-set when-list rtem)))
+             (if (and (null? ctem) (null? rtem))
+                 (chi-void)
+                 (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))))
+        ((meta-form) (chi-top (parse-meta e w ae) r w ctem rtem #t top-ribcage meta-residualize! #t))
+        ((define-syntax-form)
+         (let-values (((id rhs w) (parse-define-syntax e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       bound-id
+                       (chi rhs r r w #t)
+                       (top-ribcage-key top-ribcage)))))))))
+        ((define-form)
+         (let-values (((id rhs w) (parse-define e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (if meta?
+                     (ct-eval/residualize2 ctem
+                       (lambda ()
+                         (build-sequence no-source
+                           (list
+                             (build-cte-install bound-id
+                               (build-data no-source (make-binding 'meta-variable valsym))
+                               (top-ribcage-key top-ribcage))
+                             (build-global-definition ae valsym (chi rhs r r w #t))))))
+                    ; make sure compile-time definitions occur before we
+                    ; expand the run-time code
+                     (let ((x (ct-eval/residualize2 ctem
+                                (lambda ()
+                                  (build-cte-install
+                                    bound-id
+                                    (build-data no-source (make-binding 'global valsym))
+                                    (top-ribcage-key top-ribcage))))))
+                       (build-sequence no-source
+                         (list
+                           x
+                           (rt-eval/residualize rtem
+                             (lambda ()
+                               (build-global-definition ae valsym (chi rhs r r w #f)))))))))
+             ))))
+        (($module-form)
+         (let ((ribcage (make-empty-ribcage)))
+           (let-values (((orig id exports forms)
+                         (parse-module e w ae
+                           (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))))
+             (when (displaced-lexical? id r) (displaced-lexical-error (wrap id w)))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error orig
+                 "invalid definition in read-only environment"))
+             (chi-top-module orig r r top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!))))
+        (($import-form)
+         (let-values (((orig only? mid) (parse-import e w ae)))
+           (unless (top-ribcage-mutable? top-ribcage)
+             (syntax-error orig
+               "invalid definition in read-only environment"))
+           (ct-eval/residualize2 ctem
+             (lambda ()
+               (let ((binding (lookup (id-var-name mid empty-wrap) null-env)))
+                 (case (binding-type binding)
+                   (($module) (do-top-import only? top-ribcage mid (interface-token (binding-value binding))))
+                   ((displaced-lexical) (displaced-lexical-error mid))
+                   (else (syntax-error mid "unknown module"))))))))
+        ((alias-form)
+         (let-values (((new-id old-id) (parse-alias e w ae)))
+           (let ((new-id (wrap new-id w)))
+             (when (displaced-lexical? new-id r) (displaced-lexical-error new-id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name new-id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap new-id)) top-ribcage)))
+                 (unless (eq? (id-var-name new-id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       (make-resolved-id sym (wrap-marks (syntax-object-wrap new-id)) (id-var-name old-id w))
+                       (build-data no-source (make-binding 'do-alias #f))
+                       (top-ribcage-key top-ribcage)))))))))
+        (else
+         (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+         (if meta?
+             (let ((x (chi-expr type value e r r w ae #t)))
+               (top-level-eval-hook x)
+               (ct-eval/residualize3 ctem void (lambda () x)))
+             (rt-eval/residualize rtem
+               (lambda ()
+                 (chi-expr type value e r r w ae #f)))))))))
+
+(define flatten-exports
+  (lambda (exports)
+    (let loop ((exports exports) (ls '()))
+      (if (null? exports)
+          ls
+          (loop (cdr exports)
+                (if (pair? (car exports))
+                    (loop (car exports) ls)
+                    (cons (car exports) ls)))))))
+
+
+(define-structure (interface marks exports token))
+
+;; leaves interfaces unresolved so that indirect labels can be followed.
+;; (can't resolve until indirect labels have their final value)
+(define make-unresolved-interface
+ ; trim out implicit exports
+  (lambda (mid exports)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (if (pair? x) (car x) x)) exports))
+      #f)))
+
+(define make-resolved-interface
+ ; trim out implicit exports & resolve others to actual top-level symbol
+  (lambda (mid exports token)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (id->resolved-id (if (pair? x) (car x) x))) exports))
+      token)))
+
+(define-structure (module-binding type id label imps val exported))
+(define create-module-binding
+  (lambda (type id label imps val)
+    (make-module-binding type id label imps val #f)))
+
+;;; frobs represent body forms
+(define-structure (frob e meta?))
+
+(define chi-top-module
+  (lambda (orig r mr top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!)
+    (let ((fexports (flatten-exports exports)))
+      (let-values (((r mr bindings inits)
+                    (chi-external ribcage orig
+                      (map (lambda (d) (make-frob d meta?)) forms) r mr ctem exports fexports
+                      meta-residualize!)))
+       ; identify exported identifiers, create ctdefs
+        (let process-exports ((fexports fexports) (ctdefs (lambda () '())))
+          (if (null? fexports)
+             ; remaining bindings are either identified global vars,
+             ; local vars, or local compile-time entities
+             ; dts: type (local/global)
+             ; dvs & des: define lhs & rhs
+              (let process-locals ((bs bindings) (r r) (dts '()) (dvs '()) (des '()))
+                (if (null? bs)
+                    (let ((des (chi-frobs des r mr #f))
+                          (inits (chi-frobs inits r mr #f)))
+                      (build-sequence no-source
+                        (append
+                         ; we wait to establish global compile-time definitions so that
+                         ; expansion of des use local versions of modules and macros
+                         ; in case ctem tells us not to eval ctdefs now.  this means that
+                         ; local code can use exported compile-time values (modules, macros,
+                         ; meta variables) just as it can unexported ones.
+                          (ctdefs)
+                          (list
+                            (ct-eval/residualize2 ctem
+                              (lambda ()
+                                (let ((sym (id-sym-name id)))
+                                  (let* ((token (generate-id sym))
+                                         (b (build-data no-source
+                                              (make-binding '$module
+                                                (make-resolved-interface id exports token)))))
+                                    (let-values (((valsym bound-id)
+                                                  (top-id-bound-var-name sym
+                                                    (wrap-marks (syntax-object-wrap id))
+                                                    top-ribcage)))
+                                      (unless (eq? (id-var-name id empty-wrap) valsym)
+                                        (syntax-error orig
+                                          "definition not permitted"))
+                                      (when (read-only-binding? valsym)
+                                        (syntax-error orig
+                                          "invalid definition of read-only identifier"))
+                                      (build-cte-install bound-id b
+                                        (top-ribcage-key top-ribcage)))))))
+                            (rt-eval/residualize rtem
+                              (lambda ()
+                                (build-top-module no-source dts dvs des
+                                  (if (null? inits)
+                                      (chi-void)
+                                      (build-sequence no-source
+                                        (append inits (list (chi-void))))))))))))
+                    (let ((b (car bs)) (bs (cdr bs)))
+                      (let ((t (module-binding-type b)))
+                        (case (module-binding-type b)
+                          ((define-form)
+                           (let ((label (get-indirect-label (module-binding-label b))))
+                             (if (module-binding-exported b)
+                                 (let ((var (module-binding-id b)))
+                                   (process-locals bs r (cons 'global dts) (cons label dvs)
+                                     (cons (module-binding-val b) des)))
+                                 (let ((var (gen-var (module-binding-id b))))
+                                   (process-locals bs
+                                    ; add lexical bindings only to run-time environment
+                                     (extend-env label (make-binding 'lexical var) r)
+                                     (cons 'local dts) (cons var dvs)
+                                     (cons (module-binding-val b) des))))))
+                          ((ctdefine-form define-syntax-form $module-form alias-form) (process-locals bs r dts dvs des))
+                          (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))))
+              (let ((id (car fexports)) (fexports (cdr fexports)))
+                (let loop ((bs bindings))
+                  (if (null? bs)
+                     ; must be rexport from an imported module
+                      (process-exports fexports ctdefs)
+                      (let ((b (car bs)) (bs (cdr bs)))
+                       ; following formerly used bound-id=?, but free-id=? can prevent false positives
+                       ; and is okay since the substitutions have already been applied
+                        (if (free-id=? (module-binding-id b) id)
+                            (if (module-binding-exported b)
+                                (process-exports fexports ctdefs)
+                                (let* ((t (module-binding-type b))
+                                       (label (module-binding-label b))
+                                       (imps (module-binding-imps b))
+                                       (fexports (append imps fexports)))
+                                  (set-module-binding-exported! b #t)
+                                  (case t
+                                    ((define-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (set-indirect-label! label sym)
+                                       (process-exports fexports ctdefs)))
+                                    ((ctdefine-form)
+                                     (let ((b (module-binding-val b)))
+                                       (process-exports fexports
+                                         (lambda ()
+                                           (let ((sym (binding-value b)))
+                                             (set-indirect-label! label sym)
+                                             (cons (ct-eval/residualize3 ctem
+                                                     (lambda () (put-cte-hook sym b))
+                                                     (lambda () (build-cte-install sym (build-data no-source b) #f)))
+                                                   (ctdefs)))))))
+                                    ((define-syntax-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (process-exports fexports
+                                         (lambda () 
+                                           (let ((local-label (get-indirect-label label)))
+                                             (set-indirect-label! label sym)
+                                             (cons
+                                               (ct-eval/residualize3 ctem
+                                                 (lambda () (put-cte-hook sym (car (module-binding-val b))))
+                                                 (lambda () (build-cte-install sym (cdr (module-binding-val b)) #f)))
+                                               (ctdefs)))))))
+                                    (($module-form)
+                                     (let ((sym (generate-id (id-sym-name id)))
+                                           (exports (module-binding-val b)))
+                                       (process-exports (append (flatten-exports exports) fexports)
+                                         (lambda ()
+                                           (set-indirect-label! label sym)
+                                           (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                             (let ((x (make-binding '$module (make-resolved-interface id exports sym))))
+                                               (cons (ct-eval/residualize3 ctem
+                                                       (lambda () (put-cte-hook sym x))
+                                                       (lambda () (build-cte-install sym (build-data no-source x) #f)))
+                                                     rest)))))))
+                                    ((alias-form)
+                                     (process-exports
+                                       fexports
+                                       (lambda ()
+                                         (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                           (when (indirect-label? label)
+                                             (unless (symbol? (get-indirect-label label))
+                                               (syntax-error (module-binding-id b) "unexported target of alias")))
+                                           rest))))
+                                    (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))
+                            (loop bs))))))))))))
+
+(define id-set-diff
+  (lambda (exports defs)
+    (cond
+      ((null? exports) '())
+      ((bound-id-member? (car exports) defs) (id-set-diff (cdr exports) defs))
+      (else (cons (car exports) (id-set-diff (cdr exports) defs))))))
+
+(define check-module-exports
+  ; After processing the definitions of a module this is called to verify that the
+  ; module has defined or imported each exported identifier.  Because ids in fexports are
+  ; wrapped with the given ribcage, they will contain substitutions for anything defined
+  ; or imported here.  These subsitutions can be used by do-import! and do-import-top! to
+  ; provide access to reexported bindings, for example.
+  (lambda (source-exp fexports ids)
+    (define defined?
+      (lambda (e ids)
+        (ormap (lambda (x)
+                 (if (import-interface? x)
+                     (let ((x.iface (import-interface-interface x))
+                           (x.new-marks (import-interface-new-marks x)))
+                       (cond
+                         ((interface-token x.iface) =>
+                          (lambda (token)
+                            (lookup-import-binding-name (id-sym-name e) (id-marks e) token x.new-marks)))
+                         (else
+                          (let ((v (interface-exports x.iface)))
+                            (let lp ((i (fx- (vector-length v) 1)))
+                              (and (fx>= i 0)
+                                   (or (let ((id (vector-ref v i)))
+                                         (help-bound-id=?
+                                           (id-sym-name id)
+                                           (join-marks x.new-marks (id-marks id))
+                                           (id-sym-name e) (id-marks e)))
+                                       (lp (fx- i 1)))))))))
+                     (bound-id=? e x)))
+               ids)))
+    (let loop ((fexports fexports) (missing '()))
+      (if (null? fexports)
+          (unless (null? missing)
+            (syntax-error (car missing)
+              (if (fx= (length missing) 1)
+                  "missing definition for export"
+                  "missing definition for multiple exports, including")))
+          (let ((e (car fexports)) (fexports (cdr fexports)))
+            (if (defined? e ids)
+                (loop fexports missing)
+                (loop fexports (cons e missing))))))))
+
+(define check-defined-ids
+  (lambda (source-exp ls)
+    (define vfold
+      (lambda (v p cls)
+        (let ((len (vector-length v)))
+          (let lp ((i 0) (cls cls))
+            (if (fx= i len)
+                cls
+                (lp (fx+ i 1) (p (vector-ref v i) cls)))))))
+    (define conflicts
+      (lambda (x y cls)
+        (if (import-interface? x)
+            (let ((x.iface (import-interface-interface x))
+                  (x.new-marks (import-interface-new-marks x)))
+              (if (import-interface? y)
+                  (let ((y.iface (import-interface-interface y))
+                        (y.new-marks (import-interface-new-marks y)))
+                    (let ((xe (interface-exports x.iface)) (ye (interface-exports y.iface)))
+                      (if (fx> (vector-length xe) (vector-length ye))
+                          (vfold ye
+                            (lambda (id cls)
+                              (id-iface-conflicts id y.new-marks x.iface x.new-marks cls)) cls)
+                          (vfold xe
+                            (lambda (id cls)
+                              (id-iface-conflicts id x.new-marks y.iface y.new-marks cls)) cls))))
+                  (id-iface-conflicts y '() x.iface x.new-marks cls)))
+            (if (import-interface? y)
+                (let ((y.iface (import-interface-interface y))
+                      (y.new-marks (import-interface-new-marks y)))
+                  (id-iface-conflicts x '() y.iface y.new-marks cls))
+                (if (bound-id=? x y) (cons x cls) cls)))))
+     (define id-iface-conflicts
+       (lambda (id id.new-marks iface iface.new-marks cls)
+         (let ((id.sym (id-sym-name id))
+               (id.marks (join-marks id.new-marks (id-marks id))))
+           (cond
+             ((interface-token iface) =>
+              (lambda (token)
+                (if (lookup-import-binding-name id.sym id.marks token iface.new-marks)
+                    (cons id cls)
+                    cls)))
+             (else
+              (vfold (interface-exports iface)
+                     (lambda (*id cls)
+                       (let ((*id.sym (id-sym-name *id))
+                             (*id.marks (join-marks iface.new-marks (id-marks *id))))
+                         (if (help-bound-id=? *id.sym *id.marks id.sym id.marks)
+                             (cons *id cls)
+                             cls)))
+                     cls))))))
+     (unless (null? ls)
+       (let lp ((x (car ls)) (ls (cdr ls)) (cls '()))
+         (if (null? ls)
+             (unless (null? cls)
+               (let ((cls (syntax-object->datum cls)))
+                 (syntax-error source-exp "duplicate definition for "
+                  (symbol->string (car cls))
+                   " in")))
+             (let lp2 ((ls2 ls) (cls cls))
+               (if (null? ls2)
+                   (lp (car ls) (cdr ls) cls)
+                   (lp2 (cdr ls2) (conflicts x (car ls2) cls)))))))))
+
+(define chi-external
+  (lambda (ribcage source-exp body r mr ctem exports fexports meta-residualize!)
+    (define return
+      (lambda (r mr bindings ids inits)
+        (check-defined-ids source-exp ids)
+        (check-module-exports source-exp fexports ids)
+        (values r mr bindings inits)))
+    (define get-implicit-exports
+      (lambda (id)
+        (let f ((exports exports))
+          (if (null? exports)
+              '()
+              (if (and (pair? (car exports)) (bound-id=? id (caar exports)))
+                  (flatten-exports (cdar exports))
+                  (f (cdr exports)))))))
+    (define update-imp-exports
+      (lambda (bindings exports)
+        (let ((exports (map (lambda (x) (if (pair? x) (car x) x)) exports)))
+          (map (lambda (b)
+                 (let ((id (module-binding-id b)))
+                   (if (not (bound-id-member? id exports))
+                       b
+                       (create-module-binding
+                         (module-binding-type b)
+                         id
+                         (module-binding-label b)
+                         (append (get-implicit-exports id) (module-binding-imps b))
+                         (module-binding-val b)))))
+               bindings))))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (bindings '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr bindings ids inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (sym (generate-id (id-sym-name id)))
+                          (imps (get-implicit-exports id)))
+                     (extend-ribcage! ribcage id label)
+                     (cond
+                       (meta?
+                        (let* ((sym (generate-id (id-sym-name id)))
+                               (b (make-binding 'meta-variable sym)))
+                         ; add meta bindings only to meta environment
+                          (let ((mr (extend-env (get-indirect-label label) b mr)))
+                            (let ((exp (chi rhs mr mr w #t)))
+                              (define-top-level-value-hook sym (top-level-eval-hook exp))
+                              (meta-residualize!
+                                (ct-eval/residualize3 ctem
+                                  void
+                                  (lambda () (build-global-definition no-source sym exp))))
+                              (parse (cdr body) r mr
+                                (cons id ids)
+                                (cons (create-module-binding 'ctdefine-form id label imps b) bindings)
+                                inits
+                                #f)))))
+                       (else
+                        (parse (cdr body) r mr
+                          (cons id ids)
+                          (cons (create-module-binding type id label
+                                  imps (make-frob (wrap rhs w) meta?))
+                                bindings)
+                          inits
+                          #f))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (imps (get-implicit-exports id))
+                          (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((l (get-indirect-label label)) (b (defer-or-eval-transformer top-level-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env l b r)
+                         (extend-env l b mr)
+                         (cons id ids)
+                         (cons (create-module-binding type id label imps (cons b exp))
+                               bindings)
+                         inits
+                         #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id *exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *bindings *inits)
+                                   (chi-external *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr ctem *exports (flatten-exports *exports) meta-residualize!)))
+                       (let ((iface (make-unresolved-interface id *exports))
+                             (bindings (append *bindings bindings))
+                             (inits (append inits *inits))
+                             (label (gen-indirect-label))
+                             (imps (get-implicit-exports id)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((l (get-indirect-label label)) (b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env l b r)
+                             (extend-env l b mr)
+                             (cons id ids)
+                             (cons (create-module-binding type id label imps *exports) bindings)
+                             inits
+                             #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr
+                             (cons import-iface ids)
+                             (update-imp-exports bindings (vector->list (interface-exports iface)))
+                             inits
+                             #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+               ((alias-form)
+                (let-values (((new-id old-id) (parse-alias e w ae)))
+                  (let* ((new-id (wrap new-id w))
+                         (label (id-var-name-loc old-id w))
+                         (imps (get-implicit-exports new-id)))
+                    (extend-ribcage! ribcage new-id label)
+                    (parse (cdr body) r mr
+                      (cons new-id ids)
+                      (cons (create-module-binding type new-id label imps #f)
+                            bindings)
+                      inits
+                      #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids bindings inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                    (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                               (let f ((forms forms))
+                                 (if (null? forms)
+                                     (cdr body)
+                                     (cons (make-frob (wrap (car forms) w) meta?)
+                                           (f (cdr forms)))))
+                               (cdr body))
+                      r mr ids bindings inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids bindings inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids bindings inits #f)))
+                (else ; found an init expression
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr bindings ids (append inits body))
+                       (begin
+                        ; expand and eval meta inits for effect only
+                         (let ((x (chi-meta-frob (car body) mr)))
+                           (top-level-eval-hook x)
+                           (meta-residualize! (ct-eval/residualize3 ctem void (lambda () x))))
+                         (f (cdr body)))))))))))))
+
+(define vmap
+  (lambda (fn v)
+    (do ((i (fx- (vector-length v) 1) (fx- i 1))
+         (ls '() (cons (fn (vector-ref v i)) ls)))
+        ((fx< i 0) ls))))
+
+(define vfor-each
+  (lambda (fn v)
+    (let ((len (vector-length v)))
+      (do ((i 0 (fx+ i 1)))
+          ((fx= i len))
+        (fn (vector-ref v i))))))
+
+(define do-top-import
+  (lambda (import-only? top-ribcage mid token)
+   ; silently treat import-only like regular import at top level
+    (build-cte-install mid
+      (build-data no-source
+        (make-binding 'do-import token))
+      (top-ribcage-key top-ribcage))))
+
+(define update-mode-set
+  (let ((table
+         '((L (load . L) (compile . C) (visit . V) (revisit . R) (eval . -))
+           (C (load . -) (compile . -) (visit . -) (revisit . -) (eval . C))
+           (V (load . V) (compile . C) (visit . V) (revisit . -) (eval . -))
+           (R (load . R) (compile . C) (visit . -) (revisit . R) (eval . -))
+           (E (load . -) (compile . -) (visit . -) (revisit . -) (eval . E)))))
+    (lambda (when-list mode-set)
+      (define remq
+        (lambda (x ls)
+          (if (null? ls)
+              '()
+              (if (eq? (car ls) x)
+                  (remq x (cdr ls))
+                  (cons (car ls) (remq x (cdr ls)))))))
+      (remq '-
+        (apply append
+          (map (lambda (m)
+                 (let ((row (cdr (assq m table))))
+                   (map (lambda (s) (cdr (assq s row)))
+                        when-list)))
+               mode-set))))))
+
+(define initial-mode-set
+  (lambda (when-list compiling-a-file)
+    (apply append
+      (map (lambda (s)
+             (if compiling-a-file
+                 (case s
+                   ((compile) '(C))
+                   ((load) '(L))
+                   ((visit) '(V))
+                   ((revisit) '(R))
+                   (else '()))
+                 (case s
+                   ((eval) '(E))
+                   (else '()))))
+           when-list))))
+
+(define rt-eval/residualize
+  (lambda (rtem thunk)
+    (if (memq 'E rtem)
+        (thunk)
+        (let ((thunk (if (memq 'C rtem)
+                         (let ((x (thunk)))
+                           (top-level-eval-hook x)
+                           (lambda () x))
+                         thunk)))
+          (if (memq 'V rtem)
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (thunk) ; visit-revisit
+                  (build-visit-only (thunk)))
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (build-revisit-only (thunk))
+                  (chi-void)))))))
+
+(define ct-eval/residualize2
+  (lambda (ctem thunk)
+    (let ((t #f))
+      (ct-eval/residualize3 ctem
+        (lambda ()
+          (unless t (set! t (thunk)))
+          (top-level-eval-hook t))
+        (lambda () (or t (thunk)))))))
+
+(define ct-eval/residualize3
+  (lambda (ctem eval-thunk residualize-thunk)
+    (if (memq 'E ctem)
+        (begin (eval-thunk) (chi-void))
+        (begin
+          (when (memq 'C ctem) (eval-thunk))
+          (if (memq 'R ctem)
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (residualize-thunk) ; visit-revisit
+                  (build-revisit-only (residualize-thunk)))
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (build-visit-only (residualize-thunk))
+                  (chi-void)))))))
+
+(define chi-frobs
+  (lambda (frob* r mr m?)
+    (map (lambda (x) (chi (frob-e x) r mr empty-wrap m?)) frob*)))
+
+(define chi-meta-frob
+  (lambda (x mr)
+    (chi (frob-e x) mr mr empty-wrap #t)))
+
+(define chi-sequence
+  (lambda (body r mr w ae m?)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi (car body) r mr w m?)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi
+  (lambda (e r mr w m?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source #f)))
+      (chi-expr type value e r mr w ae m?))))
+
+(define chi-expr
+  (lambda (type value e r mr w ae m?)
+    (case type
+      ((lexical)
+       (build-lexical-reference 'value ae value))
+      ;;; AZIZ
+      ((core-primitive)
+       (build-primref ae value))
+      ((core) (value e r mr w ae m?))
+      ((lexical-call)
+       (chi-application
+         (build-lexical-reference 'fun
+           (let ((x (car e)))
+             (if (syntax-object? x) (syntax-object-expression x) x))
+           value)
+         e r mr w ae m?))
+      ((constant) (build-data ae (strip (source-wrap e w ae) empty-wrap)))
+      ((global) (build-global-reference ae value))
+      ((meta-variable)
+       (if m?
+           (build-global-reference ae value)
+           (displaced-lexical-error (source-wrap e w ae))))
+      ((call) (chi-application (chi (car e) r mr w m?) e r mr w ae m?))
+      ((begin-form) (chi-sequence (parse-begin e w ae #f) r mr w ae m?))
+      ((local-syntax-form)
+       (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+         (chi-sequence forms r mr w ae m?)))
+      ((eval-when-form)
+       (let-values (((when-list forms) (parse-eval-when e w ae)))
+         (if (memq 'eval when-list) ; mode set is implicitly (E)
+             (chi-sequence forms r mr w ae m?)
+             (chi-void))))
+      ((meta-form)
+       (syntax-error (source-wrap e w ae) "invalid context for meta definition"))
+      ((define-form)
+       (parse-define e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((define-syntax-form)
+       (parse-define-syntax e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      (($module-form)
+       (let-values (((orig id exports forms) (parse-module e w ae w)))
+         (syntax-error orig "invalid context for definition")))
+      (($import-form)
+       (let-values (((orig only? mid) (parse-import e w ae)))
+         (syntax-error orig "invalid context for definition")))
+      ((alias-form)
+       (parse-alias e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((syntax)
+       (syntax-error (source-wrap e w ae)
+         "reference to pattern variable outside syntax form"))
+      ((displaced-lexical) (displaced-lexical-error (source-wrap e w ae)))
+      (else (syntax-error (source-wrap e w ae))))))
+
+(define chi-application
+  (lambda (x e r mr w ae m?)
+    (syntax-case e ()
+      ((e0 e1 ...)
+       (build-application ae x
+         (map (lambda (e) (chi e r mr w m?)) (syntax (e1 ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-set!
+  (lambda (e r w ae rib)
+    (syntax-case e ()
+      ((_ id val)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             ((macro!)
+              (let ((id (wrap (syntax id) w)) (val (wrap (syntax val) w)))
+                (syntax-type (chi-macro (binding-value b)
+                               `(,(syntax set!) ,id ,val)
+                               r empty-wrap #f rib) r empty-wrap #f rib)))
+             (else
+              (values 'core
+                (lambda (e r mr w ae m?)
+                 ; repeat lookup in case we were first expression (init) in
+                 ; module or lambda body.  we repeat id-var-name as well,
+                 ; although this is only necessary if we allow inits to
+                 ; preced definitions
+                  (let ((val (chi (syntax val) r mr w m?))
+                        (n (id-var-name (syntax id) w)))
+                    (let ((b (lookup n r)))
+                      (case (binding-type b)
+                        ((lexical) (build-lexical-assignment ae (binding-value b) val))
+                        ((global)
+                         (let ((sym (binding-value b)))
+                           (when (read-only-binding? n)
+                             (syntax-error (source-wrap e w ae)
+                               "invalid assignment to read-only variable"))
+                           (build-global-assignment ae sym val)))
+                        ((meta-variable)
+                         (if m?
+                             (build-global-assignment ae (binding-value b) val)
+                             (displaced-lexical-error (wrap (syntax id) w))))
+                        ((displaced-lexical)
+                         (displaced-lexical-error (wrap (syntax id) w)))
+                        (else (syntax-error (source-wrap e w ae)))))))
+                e w ae))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+
+
+(define chi-macro
+  (lambda (p e r w ae rib)
+    (define rebuild-macro-output
+      (lambda (x m)
+        (cond ((pair? x)
+               (cons (rebuild-macro-output (car x) m)
+                     (rebuild-macro-output (cdr x) m)))
+              ((syntax-object? x)
+               (let ((w (syntax-object-wrap x)))
+                 (let ((ms (wrap-marks w)) (s (wrap-subst w)))
+                   (make-syntax-object (syntax-object-expression x)
+                     (if (and (pair? ms) (eq? (car ms) the-anti-mark))
+                         (make-wrap (cdr ms) (cdr s))
+                         (make-wrap (cons m ms)
+                           (if rib
+                               (cons rib (cons 'shift s))
+                               (cons 'shift s))))))))
+              ((vector? x)
+               (let* ((n (vector-length x)) (v (make-vector n)))
+                 (do ((i 0 (fx+ i 1)))
+                     ((fx= i n) v)
+                     (vector-set! v i
+                       (rebuild-macro-output (vector-ref x i) m)))))
+              ((symbol? x)
+               (syntax-error (source-wrap e w ae)
+                 "encountered raw symbol "
+                (symbol->string x)
+                 " in output of macro"))
+              (else x))))
+    (rebuild-macro-output
+      (let ((out (p (source-wrap e (anti-mark w) ae))))
+        (if (procedure? out)
+            (out (lambda (id)
+                   (unless (identifier? id)
+                     (syntax-error id
+                       "environment argument is not an identifier"))
+                   (lookup (id-var-name id empty-wrap) r)))
+            out))
+      (new-mark))))
+
+(define chi-body
+  (lambda (body outer-form r mr w m?)
+    (let* ((ribcage (make-empty-ribcage))
+           (w (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))
+           (body (map (lambda (x) (make-frob (wrap x w) #f)) body)))
+      (let-values (((r mr exprs ids vars vals inits)
+                    (chi-internal ribcage outer-form body r mr m?)))
+        (when (null? exprs) (syntax-error outer-form "no expressions in body"))
+        (build-body no-source
+          (reverse vars) (chi-frobs (reverse vals) r mr m?)
+          (build-sequence no-source
+            (chi-frobs (append inits exprs) r mr m?)))))))
+
+(define chi-internal
+  ;; In processing the forms of the body, we create a new, empty wrap.
+  ;; This wrap is augmented (destructively) each time we discover that
+  ;; the next form is a definition.  This is done:
+  ;;
+  ;;   (1) to allow the first nondefinition form to be a call to
+  ;;       one of the defined ids even if the id previously denoted a
+  ;;       definition keyword or keyword for a macro expanding into a
+  ;;       definition;
+  ;;   (2) to prevent subsequent definition forms (but unfortunately
+  ;;       not earlier ones) and the first nondefinition form from
+  ;;       confusing one of the bound identifiers for an auxiliary
+  ;;       keyword; and
+  ;;   (3) so that we do not need to restart the expansion of the
+  ;;       first nondefinition form, which is problematic anyway
+  ;;       since it might be the first element of a begin that we
+  ;;       have just spliced into the body (meaning if we restarted,
+  ;;       we'd really need to restart with the begin or the macro
+  ;;       call that expanded into the begin, and we'd have to give
+  ;;       up allowing (begin <defn>+ <expr>+), which is itself
+  ;;       problematic since we don't know if a begin contains only
+  ;;       definitions until we've expanded it).
+  ;;
+  ;; Subforms of a begin, let-syntax, or letrec-syntax are spliced
+  ;; into the body.
+  ;;
+  ;; outer-form is fully wrapped w/source
+  (lambda (ribcage source-exp body r mr m?)
+    (define return
+      (lambda (r mr exprs ids vars vals inits)
+        (check-defined-ids source-exp ids)
+        (values r mr exprs ids vars vals inits)))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (vars '()) (vals '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr body ids vars vals inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let ((id (wrap id w)) (label (gen-label)))
+                     (cond
+                       (meta?
+                        (let ((sym (generate-id (id-sym-name id))))
+                          (extend-ribcage! ribcage id label)
+                         ; add meta bindings only to meta environment
+                         ; so visible only to next higher level and beyond
+                          (let ((mr (extend-env label (make-binding 'meta-variable sym) mr)))
+                            (define-top-level-value-hook sym
+                              (top-level-eval-hook (chi rhs mr mr w #t)))
+                            (parse (cdr body) r mr (cons id ids) vars vals inits #f))))
+                       (else
+                        (let ((var (gen-var id)))
+                          (extend-ribcage! ribcage id label)
+                         ; add lexical bindings only to run-time environment
+                          (parse (cdr body)
+                            (extend-env label (make-binding 'lexical var) r)
+                            mr
+                            (cons id ids)
+                            (cons var vars)
+                            (cons (make-frob (wrap rhs w) meta?) vals)
+                            inits
+                            #f)))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let ((id (wrap id w))
+                         (label (gen-label))
+                         (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((b (defer-or-eval-transformer local-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env label b r) (extend-env label b mr)
+                         (cons id ids) vars vals inits #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *body *ids *vars *vals *inits)
+                                   (chi-internal *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr m?)))
+                      ; valid bound ids checked already by chi-internal
+                       (check-module-exports source-exp (flatten-exports exports) *ids)
+                       (let ((iface (make-resolved-interface id exports #f))
+                             (vars (append *vars vars))
+                             (vals (append *vals vals))
+                             (inits (append inits *inits *body))
+                             (label (gen-label)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env label b r) (extend-env label b mr)
+                             (cons id ids) vars vals inits #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr (cons import-iface ids) vars vals inits #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+                ((alias-form)
+                 (let-values (((new-id old-id) (parse-alias e w ae)))
+                   (let ((new-id (wrap new-id w)))
+                     (extend-ribcage! ribcage new-id (id-var-name-loc old-id w))
+                     (parse (cdr body) r mr
+                       (cons new-id ids)
+                       vars
+                       vals
+                       inits
+                       #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids vars vals inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                   (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                              (let f ((forms forms))
+                                (if (null? forms)
+                                    (cdr body)
+                                    (cons (make-frob (wrap (car forms) w) meta?)
+                                          (f (cdr forms)))))
+                              (cdr body))
+                     r mr ids vars vals inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids vars vals inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids vars vals inits #f)))
+                (else ; found a non-definition
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr body ids vars vals inits)
+                       (begin
+                        ; expand meta inits for effect only
+                         (top-level-eval-hook (chi-meta-frob (car body) mr))
+                         (f (cdr body)))))))))))))
+
+(define import-mark-delta
+ ; returns list of marks layered on top of module id beyond those
+ ; cached in the interface
+  (lambda (mid iface)
+    (diff-marks (id-marks mid) (interface-marks iface))))
+
+(define lookup-import-label
+  (lambda (id)
+    (let ((label (id-var-name-loc id empty-wrap)))
+      (unless label
+        (syntax-error id "exported identifier not visible"))
+      label)))
+  
+(define do-import!
+  (lambda (import-iface ribcage)
+    (let ((ie (interface-exports (import-interface-interface import-iface))))
+      (if (fx<= (vector-length ie) 20)
+          (let ((new-marks (import-interface-new-marks import-iface)))
+            (vfor-each
+              (lambda (id)
+                (import-extend-ribcage! ribcage new-marks id
+                  (lookup-import-label id)))
+              ie))
+          (extend-ribcage-subst! ribcage import-iface)))))
+
+(define parse-module
+  (lambda (e w ae *w)
+    (define listify
+      (lambda (exports)
+        (if (null? exports)
+            '()
+            (cons (syntax-case (car exports) ()
+                    ((ex ...) (listify (syntax (ex ...))))
+                    (x (if (id? (syntax x))
+                           (wrap (syntax x) *w)
+                           (syntax-error (source-wrap e w ae)
+                             "invalid exports list in"))))
+                  (listify (cdr exports))))))
+    (syntax-case e ()
+      ((_ orig mid (ex ...) form ...)
+       (id? (syntax mid))
+      ; id receives old wrap so it won't be confused with id of same name
+      ; defined within the module
+       (values (syntax orig) (wrap (syntax mid) w) (listify (syntax (ex ...))) (map (lambda (x) (wrap x *w)) (syntax (form ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-import
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ orig #t mid)
+       (id? (syntax mid))
+       (values (syntax orig) #t (wrap (syntax mid) w)))
+      ((_ orig #f mid)
+       (id? (syntax mid))
+       (values (syntax orig) #f (wrap (syntax mid) w)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      ((_ (name . args) e1 e2 ...)
+       (and (id? (syntax name))
+            (valid-bound-ids? (lambda-var-list (syntax args))))
+       (values (wrap (syntax name) w)
+               (cons (syntax lambda) (wrap (syntax (args e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name)
+       (id? (syntax name))
+       (values (wrap (syntax name) w) (syntax (void)) empty-wrap))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define-syntax
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (name id) e1 e2 ...)
+       (and (id? (syntax name)) (id? (syntax id)))
+       (values (wrap (syntax name) w)
+               `(,(syntax lambda) ,(wrap (syntax (id)) w)
+                   ,@(wrap (syntax (e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-meta
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ . form) (syntax form))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-eval-when
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (x ...) e1 e2 ...)
+       (values (chi-when-list (syntax (x ...)) w) (syntax (e1 e2 ...))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-alias
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ new-id old-id)
+       (and (id? (syntax new-id)) (id? (syntax old-id)))
+       (values (syntax new-id) (syntax old-id)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-begin
+  (lambda (e w ae empty-okay?)
+    (syntax-case e ()
+      ((_) empty-okay? '())
+      ((_ e1 e2 ...) (syntax (e1 e2 ...)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-lambda-clause
+  (lambda (e c r mr w m?)
+    (syntax-case c ()
+      (((id ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (values
+                 new-vars
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap ids labels w)
+                           m?))))))
+      ((ids e1 e2 ...)
+       (let ((old-ids (lambda-var-list (syntax ids))))
+         (if (not (valid-bound-ids? old-ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels old-ids))
+                   (new-vars (map gen-var old-ids)))
+               (values
+                 (let f ((ls1 (cdr new-vars)) (ls2 (car new-vars)))
+                   (if (null? ls1)
+                       ls2
+                       (f (cdr ls1) (cons (car ls1) ls2))))
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap old-ids labels w)
+                           m?))))))
+      (_ (syntax-error e)))))
+
+(define chi-local-syntax
+  (lambda (rec? e r mr w ae)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae)
+               "keyword")
+             (let ((labels (gen-labels ids)))
+               (let ((new-w (make-binding-wrap ids labels w)))
+                 (let ((b* (let ((w (if rec? new-w w)))
+                             (map (lambda (x)
+                                    (defer-or-eval-transformer
+                                      local-eval-hook
+                                      (chi x mr mr w #t)))
+                                  (syntax (val ...))))))
+                   (values
+                     (syntax (e1 e2 ...))
+                     (extend-env* labels b* r)
+                     (extend-env* labels b* mr)
+                     new-w
+                     ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-void
+  (lambda ()
+    (build-application no-source (build-primref no-source 'void) '())))
+
+(define ellipsis?
+  (lambda (x)
+    (and (nonsymbol-id? x)
+         (literal-id=? x (syntax (... ...))))))
+
+;;; data
+
+;;; strips all annotations from potentially circular reader output.
+
+(define strip-annotation
+  (lambda (x)
+    (cond
+      ((pair? x)
+       (cons (strip-annotation (car x))
+             (strip-annotation (cdr x))))
+      ((annotation? x) (annotation-stripped x))
+      (else x))))
+
+;;; strips syntax-objects down to top-wrap; if top-wrap is layered directly
+;;; on an annotation, strips the annotation as well.
+;;; since only the head of a list is annotated by the reader, not each pair
+;;; in the spine, we also check for pairs whose cars are annotated in case
+;;; we've been passed the cdr of an annotated list
+
+(define strip*
+  (lambda (x w fn)
+    (if (top-marked? w)
+        (fn x)
+        (let f ((x x))
+          (cond
+            ((syntax-object? x)
+             (strip* (syntax-object-expression x) (syntax-object-wrap x) fn))
+            ((pair? x)
+             (let ((a (f (car x))) (d (f (cdr x))))
+               (if (and (eq? a (car x)) (eq? d (cdr x)))
+                   x
+                   (cons a d))))
+            ((vector? x)
+             (let ((old (vector->list x)))
+                (let ((new (map f old)))
+                   (if (andmap eq? old new) x (list->vector new)))))
+            (else x))))))
+
+(define strip
+  (lambda (x w)
+    (strip* x w
+      (lambda (x)
+        (if (or (annotation? x) (and (pair? x) (annotation? (car x))))
+            (strip-annotation x)
+            x)))))
+
+;;; lexical variables
+
+(define gen-var
+  (lambda (id)
+    (let ((id (if (syntax-object? id) (syntax-object-expression id) id)))
+      (if (annotation? id)
+          (build-lexical-var id (annotation-expression id))
+          (build-lexical-var id id)))))
+
+(define lambda-var-list
+  (lambda (vars)
+    (let lvl ((vars vars) (ls '()) (w empty-wrap))
+       (cond
+         ((pair? vars) (lvl (cdr vars) (cons (wrap (car vars) w) ls) w))
+         ((id? vars) (cons (wrap vars w) ls))
+         ((null? vars) ls)
+         ((syntax-object? vars)
+          (lvl (syntax-object-expression vars)
+               ls
+               (join-wraps w (syntax-object-wrap vars))))
+         ((annotation? vars)
+          (lvl (annotation-expression vars) ls w))
+       ; include anything else to be caught by subsequent error
+       ; checking
+         (else (cons vars ls))))))
+
+
+; must precede global-extends
+
+(primitive-set! '$sc-put-cte
+  (lambda (id b top-token)
+     (define sc-put-module
+       (lambda (exports token new-marks)
+         (vfor-each
+           (lambda (id) (store-import-binding id token new-marks))
+           exports)))
+     (define (put-cte id binding token)
+       (let ((sym (if (symbol? id) id (id-var-name id empty-wrap))))
+        (store-import-binding id token '())
+         (put-global-definition-hook sym
+          ; global binding is assumed; if global pass #f to remove existing binding, if any
+           (if (and (eq? (binding-type binding) 'global)
+                    (eq? (binding-value binding) sym))
+               #f
+               binding))))
+     (let ((binding (make-transformer-binding b)))
+       (case (binding-type binding)
+         (($module)
+          (let ((iface (binding-value binding)))
+            (sc-put-module (interface-exports iface) (interface-token iface) '()))
+          (put-cte id binding top-token))
+         ((do-alias) (store-import-binding id top-token '()))
+         ((do-import)
+          ; fake binding: id is module id binding-value is token
+          (let ((token (binding-value b)))
+             (let ((b (lookup (id-var-name id empty-wrap) null-env)))
+               (case (binding-type b)
+                 (($module)
+                  (let* ((iface (binding-value b))
+                         (exports (interface-exports iface)))
+                    (unless (eq? (interface-token iface) token)
+                      (syntax-error id "import mismatch for module"))
+                    (sc-put-module (interface-exports iface) top-token
+                      (import-mark-delta id iface))))
+                 (else (syntax-error id "unknown module"))))))
+         (else (put-cte id binding top-token))))
+     ))
+
+
+;;; core transformers
+
+(global-extend 'local-syntax 'letrec-syntax #t)
+(global-extend 'local-syntax 'let-syntax #f)
+
+
+(global-extend 'core 'fluid-let-syntax
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((var val) ...) e1 e2 ...)
+       (valid-bound-ids? (syntax (var ...)))
+       (let ((names (map (lambda (x) (id-var-name x w)) (syntax (var ...)))))
+         (for-each
+           (lambda (id n)
+             (case (binding-type (lookup n r))
+               ((displaced-lexical) (displaced-lexical-error (wrap id w)))))
+           (syntax (var ...))
+           names)
+         (let ((b* (map (lambda (x)
+                          (defer-or-eval-transformer
+                            local-eval-hook
+                            (chi x mr mr w #t)))
+                        (syntax (val ...)))))
+           (chi-body
+             (syntax (e1 e2 ...))
+             (source-wrap e w ae)
+             (extend-env* names b* r)
+             (extend-env* names b* mr)
+             w
+             m?))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'quote
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ e) (build-data ae (strip (syntax e) w)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core '|#primitive|
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ e) (id? #'e)
+          (build-primref ae (strip (syntax e) w)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'syntax
+  (let ()
+    (define gen-syntax
+      (lambda (src e r maps ellipsis? vec?)
+        (if (id? e)
+            (let ((label (id-var-name e empty-wrap)))
+              (let ((b (lookup label r)))
+                (if (eq? (binding-type b) 'syntax)
+                    (let-values (((var maps)
+                                  (let ((var.lev (binding-value b)))
+                                    (gen-ref src (car var.lev) (cdr var.lev) maps))))
+                      (values `(ref ,var) maps))
+                    (if (ellipsis? e)
+                        (syntax-error src "misplaced ellipsis in syntax form")
+                        (values `(quote ,e) maps)))))
+            (syntax-case e ()
+              ((dots e)
+               (ellipsis? (syntax dots))
+               (if vec?
+                   (syntax-error src "misplaced ellipsis in syntax template")
+                   (gen-syntax src (syntax e) r maps (lambda (x) #f) #f)))
+              ((x dots . y)
+               ; this could be about a dozen lines of code, except that we
+               ; choose to handle (syntax (x ... ...)) forms
+               (ellipsis? (syntax dots))
+               (let f ((y (syntax y))
+                       (k (lambda (maps)
+                            (let-values (((x maps)
+                                          (gen-syntax src (syntax x) r
+                                            (cons '() maps) ellipsis? #f)))
+                              (if (null? (car maps))
+                                  (syntax-error src
+                                    "extra ellipsis in syntax form")
+                                  (values (gen-map x (car maps))
+                                          (cdr maps)))))))
+                 (syntax-case y ()
+                   ((dots . y)
+                    (ellipsis? (syntax dots))
+                    (f (syntax y)
+                       (lambda (maps)
+                         (let-values (((x maps) (k (cons '() maps))))
+                           (if (null? (car maps))
+                               (syntax-error src
+                                 "extra ellipsis in syntax form")
+                               (values (gen-mappend x (car maps))
+                                       (cdr maps)))))))
+                   (_ (let-values (((y maps) (gen-syntax src y r maps ellipsis? vec?)))
+                        (let-values (((x maps) (k maps)))
+                          (values (gen-append x y) maps)))))))
+              ((x . y)
+               (let-values (((xnew maps) (gen-syntax src (syntax x) r maps ellipsis? #f)))
+                 (let-values (((ynew maps) (gen-syntax src (syntax y) r maps ellipsis? vec?)))
+                   (values (gen-cons e (syntax x) (syntax y) xnew ynew)
+                           maps))))
+              (#(x1 x2 ...)
+               (let ((ls (syntax (x1 x2 ...))))
+                 (let-values (((lsnew maps) (gen-syntax src ls r maps ellipsis? #t)))
+                   (values (gen-vector e ls lsnew) maps))))
+              (_ (values `(quote ,e) maps))))))
+
+    (define gen-ref
+      (lambda (src var level maps)
+        (if (fx= level 0)
+            (values var maps)
+            (if (null? maps)
+                (syntax-error src "missing ellipsis in syntax form")
+                (let-values (((outer-var outer-maps) (gen-ref src var (fx- level 1) (cdr maps))))
+                  (let ((b (assq outer-var (car maps))))
+                    (if b
+                        (values (cdr b) maps)
+                        (let ((inner-var (gen-var 'tmp)))
+                          (values inner-var
+                                  (cons (cons (cons outer-var inner-var)
+                                              (car maps))
+                                        outer-maps))))))))))
+
+    (define gen-append
+      (lambda (x y)
+        (if (equal? y '(quote ()))
+            x
+            `(append ,x ,y))))
+
+    (define gen-mappend
+      (lambda (e map-env)
+        `(apply (primitive append) ,(gen-map e map-env))))
+
+    (define gen-map
+      (lambda (e map-env)
+        (let ((formals (map cdr map-env))
+              (actuals (map (lambda (x) `(ref ,(car x))) map-env)))
+          (cond
+            ((eq? (car e) 'ref)
+             ; identity map equivalence:
+             ; (map (lambda (x) x) y) == y
+             (car actuals))
+            ((andmap
+                (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) formals)))
+                (cdr e))
+             ; eta map equivalence:
+             ; (map (lambda (x ...) (f x ...)) y ...) == (map f y ...)
+             `(map (primitive ,(car e))
+                   ,@(map (let ((r (map cons formals actuals)))
+                            (lambda (x) (cdr (assq (cadr x) r))))
+                          (cdr e))))
+            (else `(map (case-lambda [,formals ,e]) ,@actuals))))))
+
+   ; 12/12/00: semantic change: we now return original syntax object (e)
+   ; if no pattern variables were found within, to avoid dropping
+   ; source annotations prematurely.  the "syntax returns lists" for
+   ; lists in its input guarantee counts only for substructure that
+   ; contains pattern variables
+    (define gen-cons
+      (lambda (e x y xnew ynew)
+        (case (car ynew)
+          ((quote)
+           (if (eq? (car xnew) 'quote)
+               (let ((xnew (cadr xnew)) (ynew (cadr ynew)))
+                 (if (and (eq? xnew x) (eq? ynew y))
+                     `',e
+                     `'(,xnew . ,ynew)))
+               (if (eq? (cadr ynew) '()) `(list ,xnew) `(cons ,xnew ,ynew))))
+          ((list) `(list ,xnew ,@(cdr ynew)))
+          (else `(cons ,xnew ,ynew)))))
+
+    (define gen-vector
+      (lambda (e ls lsnew)
+        (cond
+          ((eq? (car lsnew) 'quote)
+           (if (eq? (cadr lsnew) ls)
+               `',e
+               `(quote #(,@(cadr lsnew)))))
+          ((eq? (car lsnew) 'list) `(vector ,@(cdr lsnew)))
+          (else `(list->vector ,lsnew)))))
+
+
+    (define regen
+      (lambda (x)
+        (case (car x)
+          ((ref) (build-lexical-reference 'value no-source (cadr x)))
+          ((primitive) (build-primref no-source (cadr x)))
+          ((quote) (build-data no-source (cadr x)))
+          ((lambda) 
+           (build-lambda no-source (cadr x) (regen (caddr x))))
+          ((case-lambda)
+           (let ([d (cdr x)])
+             (build-case-lambda no-source
+              (map car d)
+              (map (lambda (x) (regen (cadr x))) d))))
+          ((map) (let ((ls (map regen (cdr x))))
+                   (build-application no-source
+                     (if (fx= (length ls) 2)
+                         (build-primref no-source 'map)
+                        ; really need to do our own checking here
+                         (build-primref no-source 2 'map)) ; require error check
+                     ls)))
+          (else (build-application no-source
+                  (build-primref no-source (car x))
+                  (map regen (cdr x)))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ x)
+           (let-values (((e maps) (gen-syntax e (syntax x) r '() ellipsis? #f)))
+             (regen e)))
+          (_ (syntax-error e)))))))
+
+
+(global-extend 'core 'lambda
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ . c)
+       (let-values (((vars body)
+                     (chi-lambda-clause 
+                       (source-wrap e w ae) 
+                       (syntax c) r mr w m?)))
+         (build-lambda ae vars body))))))
+
+;;; AZIZ
+(global-extend 'core 'case-lambda
+   (lambda (e r mr w ae m?)
+     (syntax-case e ()
+       [(_ c* ...)
+        (let-values ([(vars* body*)
+                      (let f ([c* #'(c* ...)])
+                        (syntax-case c* ()
+                          [() (values '() '())]
+                          [(c . c*) 
+                           (let-values ([(vars body)
+                                         (chi-lambda-clause
+                                           (source-wrap e w ae)
+                                           #'c r mr w m?)])
+                             (let-values ([(vars* body*) (f #'c*)])
+                               (values 
+                                 (cons vars vars*)
+                                 (cons body body*))))]))])
+           (build-case-lambda ae vars* body*))])))
+
+
+
+
+(global-extend 'core 'letrec
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae) "bound variable")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (let ((w (make-binding-wrap ids labels w))
+                    (r (extend-var-env* labels new-vars r)))
+                 (build-letrec ae
+                   new-vars
+                   (map (lambda (x) (chi x r mr w m?)) (syntax (val ...)))
+                   (chi-body (syntax (e1 e2 ...)) (source-wrap e w ae) r mr w m?)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'core 'if
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ test then)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi-void)))
+         ((_ test then else)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi (syntax else) r mr w m?)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+;;; AZIZ
+(global-extend 'core 'foreign-call
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-foreign-call ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+(global-extend 'core '$apply
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-$apply ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+;;; AZIZ
+(global-extend 'core 'type-descriptor
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ id)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             (($rtd) 
+              (build-data ae (binding-value b)))
+             (else (syntax-error (source-wrap e w ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'set! 'set! '())
+
+(global-extend 'alias 'alias '())
+(global-extend 'begin 'begin '())
+
+(global-extend '$module-key '$module '())
+(global-extend '$import '$import '())
+
+(global-extend 'define 'define '())
+
+(global-extend 'define-syntax 'define-syntax '())
+
+(global-extend 'eval-when 'eval-when '())
+
+(global-extend 'meta 'meta '())
+
+(global-extend 'core 'syntax-case
+  (let ()
+    (define convert-pattern
+      ; accepts pattern & keys
+      ; returns syntax-dispatch pattern & ids
+      (lambda (pattern keys)
+        (define cvt*
+          (lambda (p* n ids)
+            (if (null? p*)
+                (values '() ids)
+                (let-values (((y ids) (cvt* (cdr p*) n ids)))
+                  (let-values (((x ids) (cvt (car p*) n ids)))
+                    (values (cons x y) ids))))))
+        (define cvt
+          (lambda (p n ids)
+            (if (id? p)
+                (if (bound-id-member? p keys)
+                    (values (vector 'free-id p) ids)
+                    (values 'any (cons (cons p n) ids)))
+                (syntax-case p ()
+                  ((x dots)
+                   (ellipsis? (syntax dots))
+                   (let-values (((p ids) (cvt (syntax x) (fx+ n 1) ids)))
+                     (values (if (eq? p 'any) 'each-any (vector 'each p))
+                             ids)))
+                  ((x dots y ... . z)
+                   (ellipsis? (syntax dots))
+                   (let-values (((z ids) (cvt (syntax z) n ids)))
+                     (let-values (((y ids) (cvt* (syntax (y ...)) n ids)))
+                       (let-values (((x ids) (cvt (syntax x) (fx+ n 1) ids)))
+                         (values `#(each+ ,x ,(reverse y) ,z) ids)))))
+                  ((x . y)
+                   (let-values (((y ids) (cvt (syntax y) n ids)))
+                     (let-values (((x ids) (cvt (syntax x) n ids)))
+                       (values (cons x y) ids))))
+                  (() (values '() ids))
+                  (#(x ...)
+                   (let-values (((p ids) (cvt (syntax (x ...)) n ids)))
+                     (values (vector 'vector p) ids)))
+                  (x (values (vector 'atom (strip p empty-wrap)) ids))))))
+        (cvt pattern 0 '())))
+
+    (define build-dispatch-call
+      (lambda (pvars exp y r mr m?)
+        (let ((ids (map car pvars)) (levels (map cdr pvars)))
+          (let ((labels (gen-labels ids)) (new-vars (map gen-var ids)))
+            (build-application no-source
+              (build-primref no-source 'apply)
+              (list (build-lambda no-source new-vars
+                      (chi exp
+                         (extend-env*
+                             labels
+                             (map (lambda (var level)
+                                    (make-binding 'syntax `(,var . ,level)))
+                                  new-vars
+                                  (map cdr pvars))
+                             r)
+                         mr
+                         (make-binding-wrap ids labels empty-wrap)
+                         m?))
+                    y))))))
+
+    (define gen-clause
+      (lambda (x keys clauses r mr m? pat fender exp)
+        (let-values (((p pvars) (convert-pattern pat keys)))
+          (cond
+            ((not (distinct-bound-ids? (map car pvars)))
+             (invalid-ids-error (map car pvars) pat "pattern variable"))
+            ((not (andmap (lambda (x) (not (ellipsis? (car x)))) pvars))
+             (syntax-error pat
+               "misplaced ellipsis in syntax-case pattern"))
+            (else
+             (let ((y (gen-var 'tmp)))
+               ; fat finger binding and references to temp variable y
+               (build-application no-source
+                 (build-lambda no-source (list y)
+                   (let-syntax ((y (identifier-syntax
+                                     (build-lexical-reference 'value no-source y))))
+                     (build-conditional no-source
+                       (syntax-case fender ()
+                         (#t y)
+                         (_ (build-conditional no-source
+                              y
+                              (build-dispatch-call pvars fender y r mr m?)
+                              (build-data no-source #f))))
+                       (build-dispatch-call pvars exp y r mr m?)
+                       (gen-syntax-case x keys clauses r mr m?))))
+                 (list (if (eq? p 'any)
+                           (build-application no-source
+                             (build-primref no-source 'list)
+                             (list (build-lexical-reference no-source 'value x)))
+                           (build-application no-source
+                             (build-primref no-source '$syntax-dispatch)
+                             (list (build-lexical-reference no-source 'value x)
+                                   (build-data no-source p))))))))))))
+
+    (define gen-syntax-case
+      (lambda (x keys clauses r mr m?)
+        (if (null? clauses)
+            (build-application no-source
+              (build-primref no-source 'syntax-error)
+              (list (build-lexical-reference 'value no-source x)))
+            (syntax-case (car clauses) ()
+              ((pat exp)
+               (if (and (id? (syntax pat))
+                        (not (bound-id-member? (syntax pat) keys))
+                        (not (ellipsis? (syntax pat))))
+                   (let ((label (gen-label))
+                         (var (gen-var (syntax pat))))
+                     (build-application no-source
+                       (build-lambda no-source (list var)
+                         (chi (syntax exp)
+                              (extend-env label (make-binding 'syntax `(,var . 0)) r)
+                              mr
+                              (make-binding-wrap (syntax (pat))
+                                (list label) empty-wrap)
+                              m?))
+                       (list (build-lexical-reference 'value no-source x))))
+                   (gen-clause x keys (cdr clauses) r mr m?
+                     (syntax pat) #t (syntax exp))))
+              ((pat fender exp)
+               (gen-clause x keys (cdr clauses) r mr m?
+                 (syntax pat) (syntax fender) (syntax exp)))
+              (_ (syntax-error (car clauses) "invalid syntax-case clause"))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ val (key ...) m ...)
+           (if (andmap (lambda (x) (and (id? x) (not (ellipsis? x))))
+                       (syntax (key ...)))
+               (let ((x (gen-var 'tmp)))
+                 ; fat finger binding and references to temp variable x
+                 (build-application ae
+                   (build-lambda no-source (list x)
+                     (gen-syntax-case x
+                       (syntax (key ...)) (syntax (m ...))
+                       r mr m?))
+                   (list (chi (syntax val) r mr empty-wrap m?))))
+               (syntax-error e "invalid literals list in"))))))))
+
+(put-cte-hook 'module
+  (lambda (x)
+    (define proper-export?
+      (lambda (e)
+        (syntax-case e ()
+          ((id e ...)
+           (and (identifier? (syntax id))
+                (andmap proper-export? (syntax (e ...)))))
+          (id (identifier? (syntax id))))))
+    (with-syntax ((orig x))
+      (syntax-case x ()
+        ((_ (e ...) d ...)
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               (begin 
+                 ($module orig anon (e ...) d ...)
+                 ($import orig #f anon)))
+             (syntax-error x "invalid exports list in")))
+        ((_ m (e ...) d ...)
+         (identifier? (syntax m))
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               ($module orig m (e ...) d ...))
+             (syntax-error x "invalid exports list in")))))))
+
+(let ()
+  (define $module-exports
+    (lambda (m r)
+      (let ((b (r m)))
+        (case (binding-type b)
+          (($module)
+           (let* ((interface (binding-value b))
+                  (new-marks (import-mark-delta m interface)))
+             (vmap (lambda (x)
+                     (let ((id (if (pair? x) (car x) x)))
+                       (make-syntax-object
+                         (syntax-object->datum id)
+                         (let ((marks (join-marks new-marks (wrap-marks (syntax-object-wrap id))))) 
+                           (make-wrap marks
+                                     ; the anti mark should always be present at the head
+                                     ; of new-marks, but we paranoically check anyway
+                                      (if (eq? (car marks) the-anti-mark)
+                                          (cons 'shift (wrap-subst top-wrap))
+                                          (wrap-subst top-wrap)))))))
+                   (interface-exports interface))))
+          ((displaced-lexical) (displaced-lexical-error m))
+          (else (syntax-error m "unknown module"))))))
+  (define $import-help
+    (lambda (orig import-only?)
+      (lambda (r)
+        (define difference
+          (lambda (ls1 ls2)
+            (if (null? ls1)
+                ls1
+                (if (bound-id-member? (car ls1) ls2)
+                    (difference (cdr ls1) ls2)
+                    (cons (car ls1) (difference (cdr ls1) ls2))))))
+        (define prefix-add
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (datum->syntax-object id
+                  (string->symbol
+                    (string-append prefix
+                      (symbol->string (syntax-object->datum id)))))))))
+        (define prefix-drop
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (let ((s (symbol->string (syntax-object->datum id))))
+                  (let ((np (string-length prefix)) (ns (string-length s)))
+                    (unless (and (fx>= ns np) (string=? (substring s 0 np) prefix))
+                      (syntax-error id (string-append "missing expected prefix " prefix)))
+                    (datum->syntax-object id
+                      (string->symbol (substring s np ns)))))))))
+        (define gen-mid
+          (lambda (mid)
+           ; introduced module ids must have same marks as original
+           ; for import-only, since the barrier carries the marks of
+           ; the module id
+            (datum->syntax-object mid (gensym-hook))))
+        (define (modspec m exports?)
+          (with-syntax ((orig orig) (import-only? import-only?))
+            (syntax-case m (only-for-syntax also-for-syntax
+                            only except
+                            add-prefix drop-prefix rename alias)
+              ((only m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #f)))
+                 (with-syntax ((d d) (tmid (gen-mid mid)))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((except m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((id ...) (difference exports (syntax (id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((add-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-add (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((drop-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-drop (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((rename m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((tmp ...) (generate-temporaries (syntax (old-id ...))))
+                               ((other-id ...) (difference exports (syntax (old-id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id tmp) ... other-id ...)
+                                            ($module orig tmid (other-id ... (tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias new-id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+              ((alias m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((other-id ...) exports))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id old-id) ... other-id ...) d (alias new-id old-id) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+             ; base cases
+              (mid
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+              ((mid)
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+            (_ (syntax-error m "invalid module specifier")))))
+        (define modspec*
+          (lambda (m)
+            (let-values (((mid d exports) (modspec m #f))) d)))
+        (syntax-case orig ()
+          ((_ m ...)
+           (with-syntax (((d ...) (map modspec* (syntax (m ...)))))
+             (syntax (begin d ...))))))))
+
+  (put-cte-hook 'import
+    (lambda (orig)
+      ($import-help orig #f)))
+  
+  (put-cte-hook 'import-only
+    (lambda (orig)
+      ($import-help orig #t)))
+)
+
+;;; To support eval-when, we maintain two mode sets:
+;;;
+;;; ctem (compile-time-expression mode)
+;;;   determines whether/when to evaluate compile-time expressions such
+;;;   as macro definitions, module definitions, and compile-time
+;;;   registration of variable definitions
+;;;
+;;; rtem (run-time-expression mode)
+;;;   determines whether/when to evaluate run-time expressions such
+;;;   as the actual assignment performed by a variable definition or
+;;;   arbitrary top-level expressions
+
+;;; Possible modes in the mode set are:
+;;;
+;;; L (load): evaluate at load time.  implies V for compile-time
+;;;     expressions and R for run-time expressions.
+;;;
+;;; C (compile): evaluate at compile (file) time
+;;;
+;;; E (eval): evaluate at evaluation (compile or interpret) time
+;;;
+;;; V (visit): evaluate at visit time
+;;;
+;;; R (revisit): evaluate at revisit time
+
+;;; The mode set for the body of an eval-when is determined by
+;;; translating each mode in the old mode set based on the situations
+;;; present in the eval-when form and combining these into a set,
+;;; using the following table.  See also update-mode-set.
+
+;;;      load  compile  visit  revisit  eval
+;;;
+;;; L     L      C        V       R      -
+;;;
+;;; C     -      -        -       -      C
+;;;
+;;; V     V      C        V       -      -
+;;;
+;;; R     R      C        -       R      -
+;;;
+;;; E     -      -        -       -      E
+
+;;; When we complete the expansion of a compile or run-time expression,
+;;; the current ctem or rtem determines how the expression will be
+;;; treated.  See ct-eval/residualize and rt-eval/residualize.
+
+;;; Initial mode sets
+;;;
+;;; when compiling a file:
+;;;
+;;;     initial ctem: (L C)
+;;;
+;;;     initial rtem: (L)
+;;;
+;;; when not compiling a file:
+;;;
+;;;     initial ctem: (E)
+;;;
+;;;     initial rtem: (E)
+;;;
+;;;
+;;; This means that top-level syntactic definitions are evaluated
+;;; immediately after they are expanded, and the expanded definitions
+;;; are also residualized into the object file if we are compiling
+;;; a file.
+
+
+
+;;; AZIZ
+;;; (set! sc-expand
+;;;   (let ((ctem '(E)) (rtem '(E)))
+;;;     (lambda (x)
+;;;       (let ((env (interaction-environment)))
+;;;         (if (and (pair? x) (equal? (car x) noexpand))
+;;;             (cadr x)
+;;;             (chi-top* x null-env
+;;;               (env-wrap env)
+;;;               ctem rtem #f
+;;;               (env-top-ribcage env)))))))
+;;; 
+
+(primitive-set! 'expand-mode
+  (make-parameter
+    'eval
+    (lambda (x)
+      (unless (memq x '(eval compile bootstrap))
+        (error 'expand-mode "~s is not a valid mode" x))
+      x)))
+
+(primitive-set! 'sc-expand
+  (let ()
+    (define get-modes
+      (lambda ()
+        (case (expand-mode)
+          [(eval)      (values '(E)   '(E))]
+          [(compile)   (values '(L C) '(L))]
+          [(bootstrap) (values '(L)   '(L))])))
+    (lambda (x)
+      (let ((env (interaction-environment)))
+        (let-values ([(ctem rtem) (get-modes)])
+          (if (and (pair? x) (equal? (car x) noexpand))
+              (cadr x)
+              (chi-top* x null-env
+                (env-wrap env)
+                ctem rtem #f
+                (env-top-ribcage env))))))))
+
+(primitive-set! 'current-expand
+  (make-parameter
+    sc-expand
+    (lambda (x)
+      (unless (procedure? x)
+        (error 'current-expand "~s is not a procedure" x))
+      x)))
+
+(primitive-set! 'expand
+  (lambda (x)
+    ((current-expand) x)))
+
+(primitive-set! '$make-environment
+  (lambda (token mutable?)
+    (let ((top-ribcage (make-top-ribcage token mutable?)))
+      (make-env
+        top-ribcage
+        (make-wrap
+          (wrap-marks top-wrap)
+          (cons top-ribcage (wrap-subst top-wrap)))))))
+
+(primitive-set! 'environment?
+  (lambda (x)
+    (env? x)))
+
+
+;;; AZIZ
+;;; (primitive-set! 'interaction-environment
+;;;   (let ((e ($make-environment '*top* #t)))
+;;;     (lambda () e)))
+
+(primitive-set! 'interaction-environment
+  (make-parameter
+    ($make-environment '*top* #t)
+    (lambda (x)
+      (if (environment? x)
+          x
+          (error 'interaction-environment "~s is not an environment" x)))))
+
+
+(primitive-set! 'identifier?
+  (lambda (x)
+    (nonsymbol-id? x)))
+
+(primitive-set! 'datum->syntax-object
+  (lambda (id datum)
+    (arg-check nonsymbol-id? id 'datum->syntax-object)
+    (make-syntax-object
+      datum
+      (syntax-object-wrap id))))
+
+(primitive-set! 'syntax->list
+  (lambda (orig-ls)
+    (let f ((ls orig-ls))
+      (syntax-case ls ()
+        (() '())
+        ((x . r) (cons #'x (f #'r)))
+        (_ (error 'syntax->list "invalid argument ~s" orig-ls))))))
+
+(primitive-set! 'syntax->vector
+  (lambda (v)
+    (syntax-case v ()
+      (#(x ...) (apply vector (syntax->list #'(x ...))))
+      (_ (error 'syntax->vector "invalid argument ~s" v)))))
+
+(primitive-set! 'syntax-object->datum
+  ; accepts any object, since syntax objects may consist partially
+  ; or entirely of unwrapped, nonsymbolic data
+  (lambda (x)
+    (strip x empty-wrap)))
+
+(primitive-set! 'generate-temporaries
+  (lambda (ls)
+    (arg-check list? ls 'generate-temporaries)
+    (map (lambda (x) (wrap (gensym-hook) top-wrap)) ls)))
+
+(primitive-set! 'free-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'free-identifier=?)
+      (arg-check nonsymbol-id? y 'free-identifier=?)
+      (free-id=? x y)))
+
+(primitive-set! 'bound-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'bound-identifier=?)
+      (arg-check nonsymbol-id? y 'bound-identifier=?)
+      (bound-id=? x y)))
+
+(primitive-set! 'literal-identifier=?
+  (lambda (x y)
+    (arg-check nonsymbol-id? x 'literal-identifier=?)
+    (arg-check nonsymbol-id? y 'literal-identifier=?)
+    (literal-id=? x y)))
+
+(primitive-set! 'syntax-error
+  (lambda (object . messages)
+    (for-each (lambda (x) (arg-check string? x 'syntax-error)) messages)
+    (let ((message (if (null? messages)
+                       "invalid syntax"
+                       (apply string-append messages))))
+      (error-hook #f message (strip object empty-wrap)))))
+
+;;; syntax-dispatch expects an expression and a pattern.  If the expression
+;;; matches the pattern a list of the matching expressions for each
+;;; "any" is returned.  Otherwise, #f is returned.  (This use of #f will
+;;; not work on r4rs implementations that violate the ieee requirement
+;;; that #f and () be distinct.)
+
+;;; The expression is matched with the pattern as follows:
+
+;;; p in pattern:                        matches:
+;;;   ()                                 empty list
+;;;   any                                anything
+;;;   (p1 . p2)                          pair (list)
+;;;   #(free-id <key>)                   <key> with literal-identifier=?
+;;;   each-any                           any proper list
+;;;   #(each p)                          (p*)
+;;;   #(each+ p1 (p2_1 ...p2_n) p3)      (p1* (p2_n ... p2_1) . p3)
+;;;   #(vector p)                        (list->vector p)
+;;;   #(atom <object>)                   <object> with "equal?"
+
+;;; Vector cops out to pair under assumption that vectors are rare.  If
+;;; not, should convert to:
+;;;   #(vector p)                        #(p*)
+
+(let ()
+
+(define match-each
+  (lambda (e p w)
+    (cond
+      ((annotation? e)
+       (match-each (annotation-expression e) p w))
+      ((pair? e)
+       (let ((first (match (car e) p w '())))
+         (and first
+              (let ((rest (match-each (cdr e) p w)))
+                 (and rest (cons first rest))))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each (syntax-object-expression e)
+                   p
+                   (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-each+
+  (lambda (e x-pat y-pat z-pat w r)
+    (let f ((e e) (w w))
+      (cond
+        ((pair? e)
+         (let-values (((xr* y-pat r) (f (cdr e) w)))
+           (if r
+               (if (null? y-pat)
+                   (let ((xr (match (car e) x-pat w '())))
+                     (if xr
+                         (values (cons xr xr*) y-pat r)
+                         (values #f #f #f)))
+                   (values '() (cdr y-pat) (match (car e) (car y-pat) w r)))
+               (values #f #f #f))))
+        ((annotation? e) (f (annotation-expression e) w))
+        ((syntax-object? e) (f (syntax-object-expression e)
+                               (join-wraps w (syntax-object-wrap e))))
+        (else (values '() y-pat (match e z-pat w r)))))))
+
+(define match-each-any
+  (lambda (e w)
+    (cond
+      ((annotation? e)
+       (match-each-any (annotation-expression e) w))
+      ((pair? e)
+       (let ((l (match-each-any (cdr e) w)))
+         (and l (cons (wrap (car e) w) l))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each-any (syntax-object-expression e)
+                       (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-empty
+  (lambda (p r)
+    (cond
+      ((null? p) r)
+      ((eq? p 'any) (cons '() r))
+      ((pair? p) (match-empty (car p) (match-empty (cdr p) r)))
+      ((eq? p 'each-any) (cons '() r))
+      (else
+       (case (vector-ref p 0)
+         ((each) (match-empty (vector-ref p 1) r))
+         ((each+) (match-empty (vector-ref p 1)
+                    (match-empty (reverse (vector-ref p 2))
+                      (match-empty (vector-ref p 3) r))))
+         ((free-id atom) r)
+         ((vector) (match-empty (vector-ref p 1) r)))))))
+
+(define combine
+  (lambda (r* r)
+    (if (null? (car r*))
+        r
+        (cons (map car r*) (combine (map cdr r*) r)))))
+
+(define match*
+  (lambda (e p w r)
+    (cond
+      ((null? p) (and (null? e) r))
+      ((pair? p)
+       (and (pair? e) (match (car e) (car p) w
+                        (match (cdr e) (cdr p) w r))))
+      ((eq? p 'each-any)
+       (let ((l (match-each-any e w))) (and l (cons l r))))
+      (else
+       (case (vector-ref p 0)
+         ((each)
+          (if (null? e)
+              (match-empty (vector-ref p 1) r)
+              (let ((r* (match-each e (vector-ref p 1) w)))
+                (and r* (combine r* r)))))
+         ((free-id) (and (id? e) (literal-id=? (wrap e w) (vector-ref p 1)) r))
+         ((each+)
+          (let-values (((xr* y-pat r)
+                        (match-each+ e (vector-ref p 1) (vector-ref p 2)
+                          (vector-ref p 3) w r)))
+            (and r (null? y-pat)
+              (if (null? xr*)
+                  (match-empty (vector-ref p 1) r)
+                  (combine xr* r)))))
+         ((atom) (and (equal? (vector-ref p 1) (strip e w)) r))
+         ((vector)
+          (and (vector? e)
+               (match (vector->list e) (vector-ref p 1) w r))))))))
+
+(define match
+  (lambda (e p w r)
+    (cond
+      ((not r) #f)
+      ((eq? p 'any) (cons (wrap e w) r))
+      ((syntax-object? e)
+       (match*
+         (unannotate (syntax-object-expression e))
+         p
+         (join-wraps w (syntax-object-wrap e))
+         r))
+      (else (match* (unannotate e) p w r)))))
+
+(primitive-set! '$syntax-dispatch
+  (lambda (e p)
+    (cond
+      ((eq? p 'any) (list e))
+      ((syntax-object? e)
+       (match* (unannotate (syntax-object-expression e))
+         p (syntax-object-wrap e) '()))
+      (else (match* (unannotate e) p empty-wrap '())))))
+))
+
+
+(define-syntax with-syntax
+   (lambda (x)
+      (syntax-case x ()
+         ((_ () e1 e2 ...)
+          (syntax (begin e1 e2 ...)))
+         ((_ ((out in)) e1 e2 ...)
+          (syntax (syntax-case in () (out (begin e1 e2 ...)))))
+         ((_ ((out in) ...) e1 e2 ...)
+          (syntax (syntax-case (list in ...) ()
+                     ((out ...) (begin e1 e2 ...))))))))
+
+(define-syntax with-implicit
+  (syntax-rules ()
+    ((_ (tid id ...) e1 e2 ...)
+     (andmap identifier? (syntax (tid id ...)))
+     (begin
+       (unless (identifier? (syntax tid))
+         (syntax-error (syntax tid) "non-identifier with-implicit template"))
+       (with-syntax ((id (datum->syntax-object (syntax tid) 'id)) ...)
+         e1 e2 ...)))))
+
+(define-syntax datum
+  (syntax-rules ()
+    ((_ x) (syntax-object->datum (syntax x)))))
+
+(define-syntax syntax-rules
+  (lambda (x)
+    (define clause
+      (lambda (y)
+        (syntax-case y ()
+          (((keyword . pattern) template)
+           (syntax ((dummy . pattern) (syntax template))))
+          (((keyword . pattern) fender template)
+           (syntax ((dummy . pattern) fender (syntax template))))
+          (_ (syntax-error x)))))
+    (syntax-case x ()
+      ((_ (k ...) cl ...)
+       (andmap identifier? (syntax (k ...)))
+       (with-syntax (((cl ...) (map clause (syntax (cl ...)))))
+         (syntax (lambda (x) (syntax-case x (k ...) cl ...))))))))
+
+(define-syntax or
+   (lambda (x)
+      (syntax-case x ()
+         ((_) (syntax #f))
+         ((_ e) (syntax e))
+         ((_ e1 e2 e3 ...)
+          (syntax (let ((t e1)) (if t t (or e2 e3 ...))))))))
+
+(define-syntax and
+   (lambda (x)
+      (syntax-case x ()
+         ((_ e1 e2 e3 ...) (syntax (if e1 (and e2 e3 ...) #f)))
+         ((_ e) (syntax e))
+         ((_) (syntax #t)))))
+
+(define-syntax let
+   (lambda (x)
+      (syntax-case x ()
+         ((_ ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (x ...)))
+          (syntax ((lambda (x ...) e1 e2 ...) v ...)))
+         ((_ f ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (f x ...)))
+          (syntax ((letrec ((f (lambda (x ...) e1 e2 ...))) f)
+                    v ...))))))
+
+(define-syntax let*
+  (lambda (x)
+    (syntax-case x ()
+      ((let* ((x v) ...) e1 e2 ...)
+       (andmap identifier? (syntax (x ...)))
+       (let f ((bindings (syntax ((x v)  ...))))
+         (if (null? bindings)
+             (syntax (let () e1 e2 ...))
+             (with-syntax ((body (f (cdr bindings)))
+                           (binding (car bindings)))
+               (syntax (let (binding) body)))))))))
+
+(define-syntax cond
+  (lambda (x)
+    (syntax-case x ()
+      ((_ m1 m2 ...)
+       (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+         (if (null? clauses)
+             (syntax-case clause (else =>)
+               ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+               ((e0) (syntax (let ((t e0)) (if t t))))
+               ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
+               ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...))))
+               (_ (syntax-error x)))
+             (with-syntax ((rest (f (car clauses) (cdr clauses))))
+               (syntax-case clause (else =>)
+                 ((e0) (syntax (let ((t e0)) (if t t rest))))
+                 ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
+                 ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...) rest)))
+                 (_ (syntax-error x))))))))))
+
+(define-syntax do
+   (lambda (orig-x)
+      (syntax-case orig-x ()
+         ((_ ((var init . step) ...) (e0 e1 ...) c ...)
+          (with-syntax (((step ...)
+                         (map (lambda (v s)
+                                 (syntax-case s ()
+                                    (() v)
+                                    ((e) (syntax e))
+                                    (_ (syntax-error orig-x))))
+                              (syntax (var ...))
+                              (syntax (step ...)))))
+             (syntax-case (syntax (e1 ...)) ()
+                (() (syntax (let do ((var init) ...)
+                               (if (not e0)
+                                   (begin c ... (do step ...))))))
+                ((e1 e2 ...)
+                 (syntax (let do ((var init) ...)
+                            (if e0
+                                (begin e1 e2 ...)
+                                (begin c ... (do step ...))))))))))))
+
+(define-syntax quasiquote
+   (letrec
+     ; these are here because syntax-case uses literal-identifier=?,
+     ; and we want the more precise free-identifier=?
+      ((isquote? (lambda (x)
+                   (and (identifier? x)
+                        (free-identifier=? x (syntax quote)))))
+       (islist? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax list)))))
+       (iscons? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax cons)))))
+       (quote-nil? (lambda (x)
+                    (syntax-case x ()
+                      ((quote? ()) (isquote? (syntax quote?)))
+                      (_ #f))))
+       (quasilist*
+        (lambda (x y)
+          (let f ((x x))
+            (if (null? x)
+                y
+                (quasicons (car x) (f (cdr x)))))))
+       (quasicons
+        (lambda (x y)
+          (with-syntax ((x x) (y y))
+            (syntax-case (syntax y) ()
+              ((quote? dy)
+               (isquote? (syntax quote?))
+               (syntax-case (syntax x) ()
+                 ((quote? dx)
+                  (isquote? (syntax quote?))
+                  (syntax (quote (dx . dy))))
+                 (_ (if (null? (syntax dy))
+                        (syntax (list x))
+                        (syntax (cons x y))))))
+              ((listp . stuff)
+               (islist? (syntax listp))
+               (syntax (list x . stuff)))
+              (else (syntax (cons x y)))))))
+       (quasiappend
+        (lambda (x y)
+          (let ((ls (let f ((x x))
+                      (if (null? x)
+                          (if (quote-nil? y)
+                              '()
+                              (list y))
+                          (if (quote-nil? (car x))
+                              (f (cdr x))
+                              (cons (car x) (f (cdr x))))))))
+            (cond
+              ((null? ls) (syntax (quote ())))
+              ((null? (cdr ls)) (car ls))
+              (else (with-syntax (((p ...) ls))
+                      (syntax (append p ...))))))))
+       (quasivector
+        (lambda (x)
+          (with-syntax ((pat-x x))
+            (syntax-case (syntax pat-x) ()
+              ((quote? (x ...))
+               (isquote? (syntax quote?))
+               (syntax (quote #(x ...))))
+              (_ (let f ((x x) (k (lambda (ls) `(,(syntax vector) ,@ls))))
+                   (syntax-case x ()
+                     ((quote? (x ...))
+                      (isquote? (syntax quote?))
+                      (k (syntax ((quote x) ...))))
+                     ((listp x ...)
+                      (islist? (syntax listp))
+                      (k (syntax (x ...))))
+                     ((cons? x y)
+                      (iscons? (syntax cons?))
+                      (f (syntax y) (lambda (ls) (k (cons (syntax x) ls)))))
+                     (else
+                      (syntax (list->vector pat-x))))))))))
+       (vquasi
+        (lambda (p lev)
+           (syntax-case p ()
+              ((p . q)
+               (syntax-case #'p (unquote unquote-splicing)
+                 ((unquote p ...)
+                  (if (fx= lev 0)
+                      (quasilist* (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 ((unquote-splicing p ...)
+                  (if (fx= lev 0)
+                      (quasiappend (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote-splicing))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 (p (quasicons (quasi (syntax p) lev) (vquasi (syntax q) lev)))))
+              (() (syntax (quote ()))))))
+       (quasi
+        (lambda (p lev)
+           (syntax-case p (unquote unquote-splicing quasiquote)
+              ((unquote p)
+               (if (fx= lev 0)
+                   (syntax p)
+                   (quasicons (syntax (quote unquote))
+                              (quasi (syntax (p)) (fx- lev 1)))))
+              (((unquote p ...) . q)
+               (if (fx= lev 0)
+                   (quasilist* (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              (((unquote-splicing p ...) . q)
+               (if (fx= lev 0)
+                   (quasiappend (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote-splicing))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              ((quasiquote p)
+               (quasicons (syntax (quote quasiquote))
+                          (quasi (syntax (p)) (fx+ lev 1))))
+              ((p . q)
+               (quasicons (quasi (syntax p) lev) (quasi (syntax q) lev)))
+              (#(x ...) (quasivector (vquasi (syntax (x ...)) lev)))
+              (p (syntax (quote p)))))))
+    (lambda (x)
+       (syntax-case x ()
+          ((_ e) (quasi (syntax e) 0))))))
+
+(define-syntax unquote
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unquote-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax quasisyntax
+  (lambda (x)
+    (define (qs q n b* k)
+      (syntax-case q (quasisyntax unsyntax unsyntax-splicing)
+        ((quasisyntax . d)
+         (qs #'d (fx+ n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(quasisyntax . d)))))))
+        ((unsyntax . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax . d)))))))
+        ((unsyntax-splicing . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax-splicing . d)))))))
+        ((unsyntax q)
+         (fx= n 0)
+         (with-syntax (((t) (generate-temporaries #'(q))))
+           (k (cons #'(t q) b*) #'t)))
+        (((unsyntax q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'((t q) ...) b*)
+                  (with-syntax ((d dnew)) #'(t ... . d)))))))
+        (((unsyntax-splicing q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'(((t (... ...)) q) ...) b*)
+                  (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                    (with-syntax ((d dnew)) #'(m ... ... . d))))))))
+        ((a . d)
+         (qs #'a n b*
+           (lambda (b* anew)
+             (qs #'d n b*
+               (lambda (b* dnew)
+                 (k b*
+                    (if (and (eq? anew #'a) (eq? dnew #'d))
+                        q
+                        (with-syntax ((a anew) (d dnew)) #'(a . d)))))))))
+        (#(x ...)
+         (vqs #'(x ...) n b*
+           (lambda (b* xnew*)
+             (k b*
+                (if (let same? ((x* #'(x ...)) (xnew* xnew*))
+                      (if (null? x*)
+                          (null? xnew*)
+                          (and (not (null? xnew*))
+                               (eq? (car x*) (car xnew*))
+                               (same? (cdr x*) (cdr xnew*)))))
+                    q
+                    (with-syntax (((x ...) xnew*)) #'#(x ...)))))))
+        (_ (k b* q))))
+    (define (vqs x* n b* k)
+      (if (null? x*)
+          (k b* '())
+          (vqs (cdr x*) n b*
+            (lambda (b* xnew*)
+              (syntax-case (car x*) (unsyntax unsyntax-splicing)
+                ((unsyntax q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'((t q) ...) b*)
+                      (append #'(t ...) xnew*))))
+                ((unsyntax-splicing q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'(((t (... ...)) q) ...) b*)
+                      (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                        (append #'(m ... ...) xnew*)))))
+                (_ (qs (car x*) n b*
+                     (lambda (b* xnew)
+                       (k b* (cons xnew xnew*))))))))))
+    (syntax-case x ()
+      ((_ x)
+       (qs #'x 0 '()
+         (lambda (b* xnew)
+           (if (eq? xnew #'x)
+               #'(syntax x)
+               (with-syntax (((b ...) b*) (x xnew))
+                 #'(with-syntax (b ...) (syntax x))))))))))
+
+(define-syntax unsyntax
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unsyntax-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax include
+  (lambda (x)
+    (define read-file
+      (lambda (fn k)
+        (let ((p (open-input-file fn)))
+          (let f ()
+            (let ((x (read p)))
+              (if (eof-object? x)
+                  (begin (close-input-port p) '())
+                  (cons (datum->syntax-object k x) (f))))))))
+    (syntax-case x ()
+      ((k filename)
+       (let ((fn (syntax-object->datum (syntax filename))))
+         (with-syntax (((exp ...) (read-file fn (syntax k))))
+           (syntax (begin exp ...))))))))
+
+(define-syntax case
+  (lambda (x)
+    (syntax-case x ()
+      ((_ e m1 m2 ...)
+       (with-syntax
+         ((body (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+                  (if (null? clauses)
+                      (syntax-case clause (else)
+                        ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+                        (((k ...) e1 e2 ...)
+                         (syntax (if (memv t '(k ...)) (begin e1 e2 ...))))
+                        (_ (syntax-error x)))
+                      (with-syntax ((rest (f (car clauses) (cdr clauses))))
+                        (syntax-case clause (else)
+                          (((k ...) e1 e2 ...)
+                           (syntax (if (memv t '(k ...))
+                                       (begin e1 e2 ...)
+                                       rest)))
+                          (_ (syntax-error x))))))))
+         (syntax (let ((t e)) body)))))))
+
+(define-syntax identifier-syntax
+  (syntax-rules (set!)
+    ((_ e)
+     (lambda (x)
+       (syntax-case x ()
+         (id (identifier? (syntax id)) (syntax e))
+         ((_ x (... ...)) (syntax (e x (... ...)))))))
+    ((_ (id exp1) ((set! var val) exp2))
+     (and (identifier? (syntax id)) (identifier? (syntax var)))
+     (cons 'macro!
+       (lambda (x)
+         (syntax-case x (set!)
+           ((set! var val) (syntax exp2))
+           ((id x (... ...)) (syntax (exp1 x (... ...))))
+           (id (identifier? (syntax id)) (syntax exp1))))))))
+
+(define-syntax parameterize
+  (lambda (x)
+    (syntax-case x ()
+      [(_ () b b* ...) #'(let () b b* ...)]
+      [(_ ([olhs* orhs*] ...) b b* ...)
+       (with-syntax ([(lhs* ...) (generate-temporaries #'(olhs* ...))]
+                     [(rhs* ...) (generate-temporaries #'(orhs* ...))])
+        #'(let ([lhs* olhs*] ...
+                [rhs* orhs*] ...)
+            (let ([swap
+                   (lambda ()
+                     (let ([t (lhs*)])
+                       (lhs* rhs*)
+                       (set! rhs* t)) ...)])
+              (dynamic-wind
+                swap
+                (lambda () b b* ...)
+                swap))))])))
+
+(define-syntax when
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (begin b b* ...)
+         (void))]))
+
+(define-syntax unless
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (void)
+         (begin b b* ...))]))
+
+(define-syntax let-values
+  (lambda (x)
+    (define (bindem n** v**)
+      (syntax-case n** ()
+        [() #'()]
+        [((n* ...) . n**)
+         (syntax-case v** ()
+          [((v* ...) . v**)
+           (with-syntax ([rest (bindem #'n** #'v**)])
+             #'([n* v*] ... . rest))])]))
+    (syntax-case x ()
+      [(_ ([(name** ...) v*] ...) b b* ...)
+       (let ([n**
+              (let f ([n** #'((name** ...) ...)])
+                (syntax-case n** ()
+                  [() #'()]
+                  [(n* . n**)
+                   (with-syntax ([n* (generate-temporaries #'n*)]
+                                 [n** (f #'n**)])
+                     #'(n* . n**))]))])
+         (let f ([t** n**] [v* #'(v* ...)])
+           (syntax-case t** ()
+             [((t* ...) . t**) 
+              (syntax-case v* ()
+                [(v . v*)
+                 (with-syntax ([body (f #'t** #'v*)])
+                   #'(call-with-values
+                       (lambda () v)
+                       (lambda (t* ...) body)))])]
+             [() 
+              (with-syntax ([bind* (bindem #'((name** ...) ...) n**)])
+                #'(let bind* b b* ...))])))])))
+
+
+
+
+(define-syntax define-record
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append namestr "?")))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define constr (record-constructor 'rtd))
+                (define pred (record-predicate 'rtd))
+                (define getters (record-field-accessor 'rtd 'field*)) ...
+                (define setters (record-field-mutator 'rtd 'field*)) ...
+                )))])))
+
diff --git a/src/psyntax-7.1-6.9.ss b/src/psyntax-7.1-6.9.ss
new file mode 100644
index 0000000..9fe5ef9
--- /dev/null
+++ b/src/psyntax-7.1-6.9.ss
@@ -0,0 +1,4711 @@
+;;; Portable implementation of syntax-case
+;;; Extracted from Chez Scheme Version 7.1 (Aug 01, 2006)
+;;; Authors: R. Kent Dybvig, Oscar Waddell, Bob Hieb, Carl Bruggeman
+
+;;; Copyright (c) 1992-2002 Cadence Research Systems
+;;; Permission to copy this software, in whole or in part, to use this
+;;; software for any lawful purpose, and to redistribute this software
+;;; is granted subject to the restriction that all copies made of this
+;;; software must include this copyright notice in full.  This software
+;;; is provided AS IS, with NO WARRANTY, EITHER EXPRESS OR IMPLIED,
+;;; INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY
+;;; OR FITNESS FOR ANY PARTICULAR PURPOSE.  IN NO EVENT SHALL THE
+;;; AUTHORS BE LIABLE FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY
+;;; NATURE WHATSOEVER.
+
+;;; Before attempting to port this code to a new implementation of
+;;; Scheme, please read the notes below carefully.
+
+;;; This file defines the syntax-case expander, sc-expand, and a set
+;;; of associated syntactic forms and procedures.  Of these, the
+;;; following are documented in The Scheme Programming Language,
+;;; Third Edition (R. Kent Dybvig, MIT Press, 2003), which can be
+;;; found online at http://www.scheme.com/tspl3/.  Most are also documented
+;;; in the R4RS and draft R5RS.
+;;;
+;;;   bound-identifier=?
+;;;   datum->syntax-object
+;;;   define-syntax
+;;;   fluid-let-syntax
+;;;   free-identifier=?
+;;;   generate-temporaries
+;;;   identifier?
+;;;   identifier-syntax
+;;;   let-syntax
+;;;   letrec-syntax
+;;;   syntax
+;;;   syntax-case
+;;;   syntax-object->datum
+;;;   syntax-rules
+;;;   with-syntax
+;;;
+;;; All standard Scheme syntactic forms are supported by the expander
+;;; or syntactic abstractions defined in this file.  Only the R4RS
+;;; delay is omitted, since its expansion is implementation-dependent.
+
+;;; Also defined are three forms that support modules: module, import,
+;;; and import-only.  These are documented in the Chez Scheme User's
+;;; Guide (R. Kent Dybvig, Cadence Research Systems, 1998), which can
+;;; also be found online at http://www.scheme.com/csug/.  They are
+;;; described briefly here as well.
+    
+;;; All are definitions and may appear where and only where other
+;;; definitions may appear.  modules may be named:
+;;;
+;;;   (module id (ex ...) defn ... init ...)
+;;;
+;;; or anonymous:
+;;;
+;;;   (module (ex ...) defn ... init ...)
+;;;
+;;; The latter form is semantically equivalent to:
+;;;
+;;;   (module T (ex ...) defn ... init ...)
+;;;   (import T)
+;;;
+;;; where T is a fresh identifier.
+;;;
+;;; In either form, each of the exports in (ex ...) is either an
+;;; identifier or of the form (id ex ...).  In the former case, the
+;;; single identifier ex is exported.  In the latter, the identifier
+;;; id is exported and the exports ex ... are "implicitly" exported.
+;;; This listing of implicit exports is useful only when id is a
+;;; keyword bound to a transformer that expands into references to
+;;; the listed implicit exports.  In the present implementation,
+;;; listing of implicit exports is necessary only for top-level
+;;; modules and allows the implementation to avoid placing all
+;;; identifiers into the top-level environment where subsequent passes
+;;; of the compiler will be unable to deal effectively with them.
+;;;
+;;; Named modules may be referenced in import statements, which
+;;; always take one of the forms:
+;;;
+;;;   (import id)
+;;;   (import-only id)
+;;;
+;;; id must name a module.  Each exported identifier becomes visible
+;;; within the scope of the import form.  In the case of import-only,
+;;; all other identifiers become invisible in the scope of the
+;;; import-only form, except for those established by definitions
+;;; that appear textually after the import-only form.
+
+;;; import and import-only also support a variety of identifier
+;;; selection and renaming forms: only, except, add-prefix,
+;;; drop-prefix, rename, and alias.
+;;;
+;;;   (import (only m x y))
+;;; 
+;;; imports x and y (and nothing else) from m.
+;;;
+;;;   (import (except m x y))
+;;; 
+;;; imports all of m's imports except for x and y.
+;;;
+;;;   (import (add-prefix (only m x y) m:))
+;;; 
+;;; imports x and y as m:x and m:y.
+;;;
+;;;   (import (drop-prefix m foo:))
+;;; 
+;;; imports all of m's imports, dropping the common foo: prefix
+;;; (which must appear on all of m's exports).
+;;; 
+;;;   (import (rename (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, renaming c
+;;; m-c and d m-d.
+;;; 
+;;;   (import (alias (except m a b) (m-c c) (m-d d)))
+;;; 
+;;; imports all of m's imports except for x and y, with additional
+;;; aliases m-c for c and m-d for d.
+;;; 
+;;; multiple imports may be specified with one import form:
+;;; 
+;;;   (import (except m1 x) (only m2 x))
+;;; 
+;;; imports all of m1's exports except for x plus x from m2.
+
+;;; Another form, meta, may be used as a prefix for any definition and
+;;; causes any resulting variable bindings to be created at expansion
+;;; time.  Meta variables (variables defined using meta) are available
+;;; only at expansion time.  Meta definitions are often used to create
+;;; data and helpers that can be shared by multiple macros, for example:
+
+;;; (module (alpha beta)
+;;;   (meta define key-error
+;;;     (lambda (key)
+;;;       (syntax-error key "invalid key")))
+;;;   (meta define parse-keys
+;;;     (lambda (keys)
+;;;       (let f ((keys keys) (c #'white) (s 10))
+;;;         (syntax-case keys (color size)
+;;;           (() (list c s))
+;;;           (((color c) . keys) (f #'keys #'c s))
+;;;           (((size s) . keys) (f #'keys c #'s))
+;;;           ((k . keys) (key-error #'k))))))
+;;;   (define-syntax alpha
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---)))))
+;;;   (define-syntax beta
+;;;     (lambda (x)
+;;;       (syntax-case x ()
+;;;         ((_ (k ...) <other stuff>)
+;;;          (with-syntax (((c s) (parse-keys (syntax (k ...)))))
+;;;            ---))))))
+
+;;; As with define-syntax rhs expressions, meta expressions can evaluate
+;;; references only to identifiers whose values are (already) available
+;;; in the compile-time environment, e.g., macros and meta variables.
+;;; They can, however, like define-syntax rhs expressions, build syntax
+;;; objects containing occurrences of any identifiers in their scope.
+
+;;; meta definitions propagate through macro expansion, so one can write,
+;;; for example:
+;;; 
+;;;   (module (a)
+;;;     (meta define-structure (foo x))
+;;;     (define-syntax a
+;;;       (let ((q (make-foo (syntax 'q))))
+;;;         (lambda (x)
+;;;           (foo-x q)))))
+;;;   a -> q
+;;; 
+;;; where define-record is a macro that expands into a set of defines.
+;;; 
+;;; It is also sometimes convenient to write
+;;; 
+;;;   (meta begin defn ...)
+;;; 
+;;; or
+;;; 
+;;;   (meta module {exports} defn ...)
+;;; 
+;;; to create groups of meta bindings.
+
+;;; Another form, alias, is used to create aliases from one identifier
+;;; to another.  This is used primarily to support the extended import
+;;; syntaxes (add-prefix, drop-prefix, rename, and alias).
+
+;;; (let ((x 3)) (alias y x) y) -> 3
+
+;;; The remaining exports are listed below.  sc-expand, eval-when, and
+;;; syntax-error are described in the Chez Scheme User's Guide.
+;;;
+;;;   (sc-expand datum)
+;;;      if datum represents a valid expression, sc-expand returns an
+;;;      expanded version of datum in a core language that includes no
+;;;      syntactic abstractions.  The core language includes begin,
+;;;      define, if, lambda, letrec, quote, and set!.
+;;;   (eval-when situations expr ...)
+;;;      conditionally evaluates expr ... at compile-time or run-time
+;;;      depending upon situations
+;;;   (syntax-error object message)
+;;;      used to report errors found during expansion
+;;;   ($syntax-dispatch e p)
+;;;      used by expanded code to handle syntax-case matching
+;;;   ($sc-put-cte symbol val top-token)
+;;;      used to establish top-level compile-time (expand-time) bindings.
+
+;;; The following nonstandard procedures must be provided by the
+;;; implementation for this code to run.
+;;;
+;;; (void)
+;;; returns the implementation's cannonical "unspecified value".  The
+;;; following usually works:
+;;;
+;;; (define void (lambda () (if #f #f))).
+;;;
+;;; (andmap proc list1 list2 ...)
+;;; returns true if proc returns true when applied to each element of list1
+;;; along with the corresponding elements of list2 ....  The following
+;;; definition works but does no error checking:
+;;;
+;;; (define andmap
+;;;   (lambda (f first . rest)
+;;;     (or (null? first)
+;;;         (if (null? rest)
+;;;             (let andmap ((first first))
+;;;               (let ((x (car first)) (first (cdr first)))
+;;;                 (if (null? first)
+;;;                     (f x)
+;;;                     (and (f x) (andmap first)))))
+;;;             (let andmap ((first first) (rest rest))
+;;;               (let ((x (car first))
+;;;                     (xr (map car rest))
+;;;                     (first (cdr first))
+;;;                     (rest (map cdr rest)))
+;;;                 (if (null? first)
+;;;                     (apply f (cons x xr))
+;;;                     (and (apply f (cons x xr)) (andmap first rest)))))))))
+;;;
+;;; (ormap proc list1)
+;;; returns the first non-false return result of proc applied to
+;;; the elements of list1 or false if none.  The following definition
+;;; works but does no error checking:
+;;;
+;;; (define ormap
+;;;   (lambda (proc list1)
+;;;     (and (not (null? list1))
+;;;          (or (proc (car list1)) (ormap proc (cdr list1))))))
+;;;
+;;; The following nonstandard procedures must also be provided by the
+;;; implementation for this code to run using the standard portable
+;;; hooks and output constructors.  They are not used by expanded code,
+;;; and so need be present only at expansion time.
+;;;
+;;; (eval x)
+;;; where x is always in the form ("noexpand" expr).
+;;; returns the value of expr.  the "noexpand" flag is used to tell the
+;;; evaluator/expander that no expansion is necessary, since expr has
+;;; already been fully expanded to core forms.
+;;;
+;;; eval will not be invoked during the loading of psyntax.pp.  After
+;;; psyntax.pp has been loaded, the expansion of any macro definition,
+;;; whether local or global, results in a call to eval.  If, however,
+;;; sc-expand has already been registered as the expander to be used
+;;; by eval, and eval accepts one argument, nothing special must be done
+;;; to support the "noexpand" flag, since it is handled by sc-expand.
+;;;
+;;; (error who format-string why what)
+;;; where who is either a symbol or #f, format-string is always "~a ~s",
+;;; why is always a string, and what may be any object.  error should
+;;; signal an error with a message something like
+;;;
+;;;    "error in <who>: <why> <what>"
+;;;
+;;; (gensym)
+;;; returns a unique symbol each time it's called.  In Chez Scheme, gensym
+;;; returns a symbol with a "globally" unique name so that gensyms that
+;;; end up in the object code of separately compiled files cannot conflict.
+;;; This is necessary only if you intend to support compiled files.
+;;;
+;;; (gensym? x)
+;;; returns #t if x is a gensym, otherwise false.
+;;;
+;;; (putprop symbol key value)
+;;; (getprop symbol key)
+;;; (remprop symbol key)
+;;; key is always a symbol; value may be any object.  putprop should
+;;; associate the given value with the given symbol and key in some way
+;;; that it can be retrieved later with getprop.  getprop should return
+;;; #f if no value is associated with the given symbol and key.  remprop
+;;; should remove the association between the given symbol and key.
+
+;;; When porting to a new Scheme implementation, you should define the
+;;; procedures listed above, load the expanded version of psyntax.ss
+;;; (psyntax.pp, which should be available whereever you found
+;;; psyntax.ss), and register sc-expand as the current expander (how
+;;; you do this depends upon your implementation of Scheme).  You may
+;;; change the hooks and constructors defined toward the beginning of
+;;; the code below, but to avoid bootstrapping problems, do so only
+;;; after you have a working version of the expander.
+
+;;; Chez Scheme allows the syntactic form (syntax <template>) to be
+;;; abbreviated to #'<template>, just as (quote <datum>) may be
+;;; abbreviated to '<datum>.  The #' syntax makes programs written
+;;; using syntax-case shorter and more readable and draws out the
+;;; intuitive connection between syntax and quote.  If you have access
+;;; to the source code of your Scheme system's reader, you might want
+;;; to implement this extension.
+
+;;; If you find that this code loads or runs slowly, consider
+;;; switching to faster hardware or a faster implementation of
+;;; Scheme.  In Chez Scheme on a 200Mhz Pentium Pro, expanding,
+;;; compiling (with full optimization), and loading this file takes
+;;; between one and two seconds.
+
+;;; In the expander implementation, we sometimes use syntactic abstractions
+;;; when procedural abstractions would suffice.  For example, we define
+;;; top-wrap and top-marked? as
+;;;   (define-syntax top-wrap (identifier-syntax '((top))))
+;;;   (define-syntax top-marked?
+;;;     (syntax-rules ()
+;;;       ((_ w) (memq 'top (wrap-marks w)))))
+;;; rather than
+;;;   (define top-wrap '((top)))
+;;;   (define top-marked?
+;;;     (lambda (w) (memq 'top (wrap-marks w))))
+;;; On ther other hand, we don't do this consistently; we define make-wrap,
+;;; wrap-marks, and wrap-subst simply as
+;;;   (define make-wrap cons)
+;;;   (define wrap-marks car)
+;;;   (define wrap-subst cdr)
+;;; In Chez Scheme, the syntactic and procedural forms of these
+;;; abstractions are equivalent, since the optimizer consistently
+;;; integrates constants and small procedures.  Some Scheme
+;;; implementations, however, may benefit from more consistent use
+;;; of one form or the other.
+
+
+;;; Implementation notes:
+
+;;; "begin" is treated as a splicing construct at top level and at
+;;; the beginning of bodies.  Any sequence of expressions that would
+;;; be allowed where the "begin" occurs is allowed.
+
+;;; "let-syntax" and "letrec-syntax" are also treated as splicing
+;;; constructs, in violation of the R5RS.  A consequence is that let-syntax
+;;; and letrec-syntax do not create local contours, as do let and letrec.
+;;; Although the functionality is greater as it is presently implemented,
+;;; we will probably change it to conform to the R5RS.  modules provide
+;;; similar functionality to nonsplicing letrec-syntax when the latter is
+;;; used as a definition.
+
+;;; Objects with no standard print syntax, including objects containing
+;;; cycles and syntax objects, are allowed in quoted data as long as they
+;;; are contained within a syntax form or produced by datum->syntax-object.
+;;; Such objects are never copied.
+
+;;; When the expander encounters a reference to an identifier that has
+;;; no global or lexical binding, it treats it as a global-variable
+;;; reference.  This allows one to write mutually recursive top-level
+;;; definitions, e.g.:
+;;;
+;;;   (define f (lambda (x) (g x)))
+;;;   (define g (lambda (x) (f x)))
+;;;
+;;; but may not always yield the intended when the variable in question
+;;; is later defined as a keyword.
+
+;;; Top-level variable definitions of syntax keywords are permitted.
+;;; In order to make this work, top-level define not only produces a
+;;; top-level definition in the core language, but also modifies the
+;;; compile-time environment (using $sc-put-cte) to record the fact
+;;; that the identifier is a variable.
+
+;;; Top-level definitions of macro-introduced identifiers are visible
+;;; only in code produced by the macro.  That is, a binding for a
+;;; hidden (generated) identifier is created instead, and subsequent
+;;; references within the macro output are renamed accordingly.  For
+;;; example:
+;;;
+;;; (define-syntax a
+;;;   (syntax-rules ()
+;;;     ((_ var exp)
+;;;      (begin
+;;;        (define secret exp)
+;;;        (define var
+;;;          (lambda ()
+;;;            (set! secret (+ secret 17))
+;;;            secret))))))
+;;; (a x 0)
+;;; (x) => 17
+;;; (x) => 34
+;;; secret => Error: variable secret is not bound
+;;;
+;;; The definition above would fail if the definition for secret
+;;; were placed after the definition for var, since the expander would
+;;; encounter the references to secret before the definition that
+;;; establishes the compile-time map from the identifier secret to
+;;; the generated identifier.
+
+;;; Identifiers and syntax objects are implemented as vectors for
+;;; portability.  As a result, it is possible to "forge" syntax
+;;; objects.
+
+;;; The input to sc-expand may contain "annotations" describing, e.g., the
+;;; source file and character position from where each object was read if
+;;; it was read from a file.  These annotations are handled properly by
+;;; sc-expand only if the annotation? hook (see hooks below) is implemented
+;;; properly and the operators annotation-expression and annotation-stripped
+;;; are supplied.  If annotations are supplied, the proper annotated
+;;; expression is passed to the various output constructors, allowing
+;;; implementations to accurately correlate source and expanded code.
+;;; Contact one of the authors for details if you wish to make use of
+;;; this feature.
+
+;;; Implementation of modules:
+;;;
+;;; The implementation of modules requires that implicit top-level exports
+;;; be listed with the exported macro at some level where both are visible,
+;;; e.g.,
+;;;
+;;;   (module M (alpha (beta b))
+;;;     (module ((alpha a) b)
+;;;       (define-syntax alpha (identifier-syntax a))
+;;;       (define a 'a)
+;;;       (define b 'b))
+;;;     (define-syntax beta (identifier-syntax b)))
+;;;
+;;; Listing of implicit imports is not needed for macros that do not make
+;;; it out to top level, including all macros that are local to a "body".
+;;; (They may be listed in this case, however.)  We need this information
+;;; for top-level modules since a top-level module expands into a letrec
+;;; for non-top-level variables and top-level definitions (assignments) for
+;;; top-level variables.  Because of the general nature of macro
+;;; transformers, we cannot determine the set of implicit exports from the
+;;; transformer code, so without the user's help, we'd have to put all
+;;; variables at top level.
+;;;
+;;; Each such top-level identifier is given a generated name (gensym).
+;;; When a top-level module is imported at top level, a compile-time
+;;; alias is established from the top-level name to the generated name.
+;;; The expander follows these aliases transparently.  When any module is
+;;; imported anywhere other than at top level, the id-var-name of the
+;;; import identifier is set to the id-var-name of the export identifier.
+;;; Since we can't determine the actual labels for identifiers defined in
+;;; top-level modules until we determine which are placed in the letrec
+;;; and which make it to top level, we give each an "indirect" label---a
+;;; pair whose car will eventually contain the actual label.  Import does
+;;; not follow the indirect, but id-var-name does.
+;;;
+;;; All identifiers defined within a local module are folded into the
+;;; letrec created for the enclosing body.  Visibility is controlled in
+;;; this case and for nested top-level modules by introducing a new wrap
+;;; for each module.
+
+
+;;; Bootstrapping:
+
+;;; When changing syntax-object representations, it is necessary to support
+;;; both old and new syntax-object representations in id-var-name.  It
+;;; should be sufficient to redefine syntax-object-expression to work for
+;;; both old and new representations and syntax-object-wrap to return the
+;;; empty-wrap for old representations.
+
+
+;;; The following set of definitions establishes bindings for the
+;;; top-level variables assigned values in the let expression below.
+;;; Uncomment them here and copy them to the front of psyntax.pp if
+;;; required by your system.
+
+; (define $sc-put-cte #f)
+; (define sc-expand #f)
+; (define $make-environment #f)
+; (define environment? #f)
+; (define interaction-environment #f)
+; (define identifier? #f)
+; (define syntax->list #f)
+; (define syntax-object->datum #f)
+; (define datum->syntax-object #f)
+; (define generate-temporaries #f)
+; (define free-identifier=? #f)
+; (define bound-identifier=? #f)
+; (define literal-identifier=? #f)
+; (define syntax-error #f)
+; (define $syntax-dispatch #f)
+
+
+(let ()
+
+(define-syntax when
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (if test (begin e1 e2 ...)))))
+(define-syntax unless
+  (syntax-rules ()
+    ((_ test e1 e2 ...) (when (not test) (begin e1 e2 ...)))))
+(define-syntax define-structure
+  (lambda (x)
+    (define construct-name
+      (lambda (template-identifier . args)
+        (datum->syntax-object
+          template-identifier
+          (string->symbol
+            (apply string-append
+                   (map (lambda (x)
+                          (if (string? x)
+                              x
+                              (symbol->string (syntax-object->datum x))))
+                        args))))))
+    (syntax-case x ()
+      ((_ (name id1 ...))
+       (andmap identifier? (syntax (name id1 ...)))
+       (with-syntax
+         ((constructor (construct-name (syntax name) "make-" (syntax name)))
+          (predicate (construct-name (syntax name) (syntax name) "?"))
+          ((access ...)
+           (map (lambda (x) (construct-name x (syntax name) "-" x))
+                (syntax (id1 ...))))
+          ((assign ...)
+           (map (lambda (x)
+                  (construct-name x "set-" (syntax name) "-" x "!"))
+                (syntax (id1 ...))))
+          (structure-length
+           (fx+ (length (syntax (id1 ...))) 1))
+          ((index ...)
+           (let f ((i 1) (ids (syntax (id1 ...))))
+              (if (null? ids)
+                  '()
+                  (cons i (f (fx+ i 1) (cdr ids)))))))
+         (syntax (begin
+                   (define constructor
+                     (lambda (id1 ...)
+                       (vector 'name id1 ... )))
+                   (define predicate
+                     (lambda (x)
+                       (and (vector? x)
+                            (fx= (vector-length x) structure-length)
+                            (eq? (vector-ref x 0) 'name))))
+                   (define access
+                     (lambda (x)
+                       (vector-ref x index)))
+                   ...
+                   (define assign
+                     (lambda (x update)
+                       (vector-set! x index update)))
+                   ...)))))))
+
+(define-syntax let-values ; impoverished one-clause version
+  (syntax-rules ()
+    ((_ ((formals expr)) form1 form2 ...)
+     (call-with-values (lambda () expr) (lambda formals form1 form2 ...)))))
+
+(define noexpand "noexpand")
+
+(define-structure (syntax-object expression wrap))
+
+;;; hooks to nonportable run-time helpers
+(begin
+;(define-syntax fx+ (identifier-syntax +))
+;(define-syntax fx- (identifier-syntax -))
+;(define-syntax fx= (identifier-syntax =))
+;(define-syntax fx< (identifier-syntax <))
+;(define-syntax fx> (identifier-syntax >))
+;(define-syntax fx<= (identifier-syntax <=))
+;(define-syntax fx>= (identifier-syntax >=))
+
+(define annotation? (lambda (x) #f))
+(define annotation-expression 
+  (lambda (x) (error 'annotation-expression "not yet")))
+(define annotation-stripped 
+  (lambda (x) (error 'annotation-stripped "not yet")))
+
+; top-level-eval-hook is used to create "permanent" code (e.g., top-level
+; transformers), so it might be a good idea to compile it
+(define top-level-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+; local-eval-hook is used to create "temporary" code (e.g., local
+; transformers), so it might be a good idea to interpret it
+(define local-eval-hook
+  (lambda (x)
+    (eval `(,noexpand ,x))))
+
+(define define-top-level-value-hook
+  (lambda (sym val)
+    (top-level-eval-hook
+      (build-global-definition no-source sym
+        (build-data no-source val)))))
+
+(define error-hook
+  (lambda (who why what)
+    (error who "~a ~s" why what)))
+
+(define-syntax gensym-hook
+  (syntax-rules ()
+    ((_) (gensym))))
+
+;;; AZIZ
+;;; (define put-cte-hook
+;;;   (lambda (symbol val)
+;;;     ($sc-put-cte symbol val '*top*)))
+
+(define put-cte-hook
+  (lambda (symbol val)
+    ($sc-put-cte symbol val '*top*)))
+
+(define get-global-definition-hook
+  (lambda (symbol)
+    (getprop symbol '*sc-expander*)))
+
+(define put-global-definition-hook
+  (lambda (symbol x)
+    (if (not x)
+        (remprop symbol '*sc-expander*)
+        (putprop symbol '*sc-expander* x))))
+
+; if you treat certain bindings (say from environments like ieee or r5rs)
+; read-only, this should return #t for those bindings
+(define read-only-binding?
+  (lambda (symbol)
+    #f))
+
+; should return #f if symbol has no binding for token
+(define get-import-binding
+  (lambda (symbol token)
+    (getprop symbol token)))
+
+; remove binding if x is false
+(define put-import-binding
+  (lambda (symbol token x)
+    (if (not x)
+        (remprop symbol token)
+        (putprop symbol token x))))
+
+;;; generate-id ideally produces globally unique symbols, i.e., symbols
+;;; unique across system runs, to support separate compilation/expansion.
+;;; Use gensym-hook if you do not need to support separate compilation/
+;;; expansion or if your system's gensym creates globally unique
+;;; symbols (as in Chez Scheme).  Otherwise, use the following code
+;;; as a starting point.  session-key should be a unique string for each
+;;; system run to support separate compilation; the default value given
+;;; is satisfactory during initial development only.
+;(define generate-id
+;  (let ((digits "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/:<=>?~_^.+-"))
+;    (let ((base (string-length digits)) (session-key "_"))
+;      (define make-digit (lambda (x) (string-ref digits x)))
+;      (define fmt
+;        (lambda (n)
+;          (let fmt ((n n) (a '()))
+;            (if (< n base)
+;                (list->string (cons (make-digit n) a))
+;                (let ((r (modulo n base)) (rest (quotient n base)))
+;                  (fmt rest (cons (make-digit r) a)))))))
+;      (let ((n -1))
+;        (lambda (name) ; name is #f or a symbol
+;          (set! n (+ n 1))
+;          (string->symbol (string-append session-key (fmt n))))))))
+;;; AZIZ
+(define generate-id
+  (lambda (name)
+    (if name (gensym (symbol->string name)) (gensym))))
+)
+
+
+
+;;; output constructors
+(begin
+(define-syntax build-application
+  (syntax-rules ()
+    ((_ ae fun-exp arg-exps)
+     `(,fun-exp . ,arg-exps))))
+
+(define-syntax build-conditional
+  (syntax-rules ()
+    ((_ ae test-exp then-exp else-exp)
+     `(if ,test-exp ,then-exp ,else-exp))))
+
+(define-syntax build-lexical-reference
+  (syntax-rules ()
+    ((_ type ae var)
+     var)))
+
+(define-syntax build-lexical-assignment
+  (syntax-rules ()
+    ((_ ae var exp)
+     `(set! ,var ,exp))))
+
+;;; AZIZ
+;;; (define-syntax build-global-reference
+;;;   (syntax-rules ()
+;;;     ((_ ae var)
+;;;      var)))
+(define-syntax build-global-reference
+  (syntax-rules ()
+    [(_ ae var)
+     `(top-level-value ',var)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-assignment
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(set! ,var ,exp))))
+(define-syntax build-global-assignment
+  (syntax-rules ()
+    [(_ ae var exp)
+     `(set-top-level-value! ',var ,exp)]))
+
+;;; AZIZ
+;;; (define-syntax build-global-definition
+;;;   (syntax-rules ()
+;;;     ((_ ae var exp)
+;;;      `(define ,var ,exp))))
+(define-syntax build-global-definition
+  (syntax-rules ()
+    [(_ ae var exp)
+     (build-global-assignment ae var exp)]))
+
+
+(define-syntax build-cte-install
+ ; should build a call that has the same effect as calling put-cte-hook
+  (syntax-rules ()
+    ((_ sym exp token) 
+     `(#%$sc-put-cte ',sym ,exp ',token))))
+
+(define-syntax build-visit-only
+ ; should mark the result as "visit only" for compile-file
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+(define-syntax build-revisit-only
+ ; should mark the result as "revisit only" for compile-file,
+ ; in implementations that support visit/revisit
+  (syntax-rules ()
+    ((_ exp) exp)))
+
+;;; AZIZ
+;;; (define-syntax build-lambda
+;;;   (syntax-rules ()
+;;;     ((_ ae vars exp)
+;;;      `(lambda ,vars ,exp))))
+(define-syntax build-lambda
+  (syntax-rules ()
+    [(_ ae vars exp)
+     `(case-lambda [,vars ,exp])]))
+
+(define build-case-lambda
+  (lambda (ae vars* exp*)
+    `(case-lambda . ,(map list vars* exp*))))
+
+;;; AZIZ
+;;; (define built-lambda?
+;;;   (lambda (x)
+;;;     (and (pair? x) (eq? (car x) 'lambda))))
+(define built-lambda?
+  (lambda (x)
+    (and (pair? x) (eq? (car x) 'case-lambda))))
+
+;;; AZIZ
+;;; (define-syntax build-primref
+;;;   (syntax-rules ()
+;;;     ((_ ae name) name)
+;;;     ((_ ae level name) name)))
+(define-syntax build-primref
+  (syntax-rules ()
+    [(_ ae name)   (build-primref ae 1 name)]
+    [(_ ae level name)
+     `(|#primitive| ,name)]))
+
+
+;;; AZIZ
+(define-syntax build-foreign-call
+  (syntax-rules ()
+    [(_ ae name arg*) `(foreign-call ,name . ,arg*)]))
+(define-syntax build-$apply
+  (syntax-rules ()
+    [(_ ae proc arg*) `($apply ,proc . ,arg*)]))
+
+(define-syntax build-data
+  (syntax-rules ()
+    ((_ ae exp) `',exp)))
+
+(define build-sequence
+  (lambda (ae exps)
+    (let loop ((exps exps))
+      (if (null? (cdr exps))
+          (car exps)
+         ; weed out leading void calls, assuming ordinary list representation
+          (if (equal? (car exps) '(#%void))
+              (loop (cdr exps))
+              `(begin ,@exps))))))
+
+(define build-letrec
+  (lambda (ae vars val-exps body-exp)
+    (if (null? vars)
+        body-exp
+        `(letrec ,(map list vars val-exps) ,body-exp))))
+
+
+(define build-body
+  (lambda (ae vars val-exps body-exp)
+    (build-letrec ae vars val-exps body-exp)))
+
+(define build-top-module
+ ; each type is either global (exported) or local (not exported)
+ ; we produce global definitions and assignments for globals and
+ ; letrec bindings for locals.  if you don't need the definitions,
+ ; (just assignments) you can eliminate them.  if you wish to
+ ; have your module definitions ordered from left-to-right (ala
+ ; letrec*), you can replace the global var-exps with dummy vars
+ ; and global val-exps with global assignments, and produce a letrec*
+ ; in place of a letrec.
+  (lambda (ae types vars val-exps body-exp)
+    (let-values (((vars defns sets)
+                  (let f ((types types) (vars vars))
+                    (if (null? types)
+                        (values '() '() '())
+                        (let ((var (car vars)))
+                          (let-values (((vars defns sets) (f (cdr types) (cdr vars))))
+                            (if (eq? (car types) 'global)
+                                (let ((x (build-lexical-var no-source var)))
+                                  (values
+                                    (cons x vars)
+                                    (cons (build-global-definition no-source var (chi-void)) defns)
+                                    (cons (build-global-assignment no-source var (build-lexical-reference 'value no-source x)) sets)))
+                                (values (cons var vars) defns sets))))))))
+      (if (null? defns)
+          (build-letrec ae vars val-exps body-exp)
+          (build-sequence no-source
+            (append defns
+              (list
+                (build-letrec ae vars val-exps
+                  (build-sequence no-source (append sets (list body-exp)))))))))))
+
+(define-syntax build-lexical-var
+  (syntax-rules ()
+    ((_ ae id) (gensym))))
+
+(define-syntax lexical-var? gensym?)
+
+(define-syntax self-evaluating?
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (or (boolean? x) (fixnum? x) (string? x) (char? x) (null? x))))))
+)
+
+(define-syntax unannotate
+  (syntax-rules ()
+    ((_ x)
+     (let ((e x))
+       (if (annotation? e)
+           (annotation-expression e)
+           e)))))
+
+(define-syntax no-source (identifier-syntax #f))
+
+(define-syntax arg-check
+  (syntax-rules ()
+    ((_ pred? e who)
+     (let ((x e))
+       (if (not (pred? x)) (error-hook who "invalid argument" x))))))
+
+;;; compile-time environments
+
+;;; wrap and environment comprise two level mapping.
+;;;   wrap : id --> label
+;;;   env : label --> <element>
+
+;;; environments are represented in two parts: a lexical part and a global
+;;; part.  The lexical part is a simple list of associations from labels
+;;; to bindings.  The global part is implemented by
+;;; {put,get}-global-definition-hook and associates symbols with
+;;; bindings.
+
+;;; global (assumed global variable) and displaced-lexical (see below)
+;;; do not show up in any environment; instead, they are fabricated by
+;;; lookup when it finds no other bindings.
+
+;;; <environment>              ::= ((<label> . <binding>)*)
+
+;;; identifier bindings include a type and a value
+
+;;; <binding> ::= <procedure>                     macro keyword
+;;;               (macro . <procedure>)           macro keyword
+;;;               (deferred . <thunk>)            macro keyword w/lazily evaluated transformer
+;;;               (macro! . <procedure>)          extended identifier macro keyword
+;;;               (core . <procedure>)            core keyword
+;;;               (begin)                         begin keyword
+;;;               (define)                        define keyword
+;;;               (define-syntax)                 define-syntax keyword
+;;;               (local-syntax . <boolean>)      let-syntax (#f)/letrec-syntax (#t) keyword
+;;;               (eval-when)                     eval-when keyword
+;;;               (set!)                          set! keyword
+;;;               (meta)                          meta keyword
+;;;               ($module-key)                   $module keyword
+;;;               ($import)                       $import keyword
+;;;               ($module . <interface>)         modules
+;;;               (syntax . (<var> . <level>))    pattern variables
+;;;               (global . <symbol>)             assumed global variable
+;;;               (meta-variable . <symbol>)      meta variable
+;;;               (lexical . <var>)               lexical variables
+;;;               (displaced-lexical . #f)        id-var-name not found in store
+;;; <level>   ::= <nonnegative integer>
+;;; <var>     ::= variable returned by build-lexical-var
+
+;;; a macro is a user-defined syntactic-form.  a core is a system-defined
+;;; syntactic form.  begin, define, define-syntax, let-syntax, letrec-syntax,
+;;; eval-when, and meta are treated specially since they are sensitive to
+;;; whether the form is at top-level and can denote valid internal
+;;; definitions.
+
+;;; a pattern variable is a variable introduced by syntax-case and can
+;;; be referenced only within a syntax form.
+
+;;; any identifier for which no top-level syntax definition or local
+;;; binding of any kind has been seen is assumed to be a global
+;;; variable.
+
+;;; a lexical variable is a lambda- or letrec-bound variable.
+
+;;; a displaced-lexical identifier is a lexical identifier removed from
+;;; it's scope by the return of a syntax object containing the identifier.
+;;; a displaced lexical can also appear when a letrec-syntax-bound
+;;; keyword is referenced on the rhs of one of the letrec-syntax clauses.
+;;; a displaced lexical should never occur with properly written macros.
+
+(define sanitize-binding
+  (lambda (b)
+    (cond
+      ((procedure? b) (make-binding 'macro b))
+      ((binding? b)
+       (and (case (binding-type b)
+              ((core macro macro! deferred)
+               (and (procedure? (binding-value b))))
+              (($module) (interface? (binding-value b)))
+              ((lexical) (lexical-var? (binding-value b)))
+              ((global meta-variable) (symbol? (binding-value b)))
+              ((syntax) (let ((x (binding-value b)))
+                          (and (pair? x)
+                               (lexical-var? (car x))
+                               (let ((n (cdr x)))
+                                 (and (fixnum? n) (fx>= n 0))))))
+              ((begin define define-syntax set! $module-key $import eval-when meta) (null? (binding-value b)))
+              ((local-syntax) (boolean? (binding-value b)))
+              ((displaced-lexical) (eq? (binding-value b) #f))
+              (else #t))
+            b))
+      (else #f))))
+
+(define-syntax make-binding
+  (syntax-rules (quote)
+    ((_ 'type #f) '(type . #f))
+    ((_ type value) (cons type value))))
+
+(define binding-type car)
+(define binding-value cdr)
+(define set-binding-type! set-car!)
+(define set-binding-value! set-cdr!)
+(define binding? (lambda (x) (and (pair? x) (symbol? (car x)))))
+
+(define-syntax null-env (identifier-syntax '()))
+
+(define extend-env
+  (lambda (label binding r)
+    (cons (cons label binding) r)))
+
+(define extend-env*
+  (lambda (labels bindings r)
+    (if (null? labels)
+        r
+        (extend-env* (cdr labels) (cdr bindings)
+          (extend-env (car labels) (car bindings) r)))))
+
+(define extend-var-env*
+  ; variant of extend-env* that forms "lexical" binding
+  (lambda (labels vars r)
+    (if (null? labels)
+        r
+        (extend-var-env* (cdr labels) (cdr vars)
+          (extend-env (car labels) (make-binding 'lexical (car vars)) r)))))
+
+(define (displaced-lexical? id r)
+  (let ((n (id-var-name id empty-wrap)))
+    (and n
+         (let ((b (lookup n r)))
+           (eq? (binding-type b) 'displaced-lexical)))))
+
+(define displaced-lexical-error
+  (lambda (id)
+    (syntax-error id
+      (if (id-var-name id empty-wrap)
+          "identifier out of context"
+          "identifier not visible"))))
+
+(define lookup*
+  ; x may be a label or a symbol
+  ; although symbols are usually global, we check the environment first
+  ; anyway because a temporary binding may have been established by
+  ; fluid-let-syntax
+  (lambda (x r)
+    (cond
+      ((assq x r) => cdr)
+      ((symbol? x)
+       (or (get-global-definition-hook x) (make-binding 'global x)))
+      (else (make-binding 'displaced-lexical #f)))))
+
+(define lookup
+  (lambda (x r)
+    (define whack-binding!
+      (lambda (b *b)
+        (set-binding-type! b (binding-type *b))
+        (set-binding-value! b (binding-value *b))))
+    (let ((b (lookup* x r)))
+      (when (eq? (binding-type b) 'deferred)
+        (whack-binding! b (make-transformer-binding ((binding-value b)))))
+      b)))
+
+(define make-transformer-binding
+  (lambda (b)
+    (or (sanitize-binding b)
+        (syntax-error b "invalid transformer"))))
+
+(define defer-or-eval-transformer
+  (lambda (eval x)
+    (if (built-lambda? x)
+        (make-binding 'deferred (lambda () (eval x)))
+        (make-transformer-binding (eval x)))))
+
+(define global-extend
+  (lambda (type sym val)
+    (put-cte-hook sym (make-binding type val))))
+
+
+;;; Conceptually, identifiers are always syntax objects.  Internally,
+;;; however, the wrap is sometimes maintained separately (a source of
+;;; efficiency and confusion), so that symbols are also considered
+;;; identifiers by id?.  Externally, they are always wrapped.
+
+(define nonsymbol-id?
+  (lambda (x)
+    (and (syntax-object? x)
+         (symbol? (unannotate (syntax-object-expression x))))))
+
+(define id?
+  (lambda (x)
+    (cond
+      ((symbol? x) #t)
+      ((syntax-object? x) (symbol? (unannotate (syntax-object-expression x))))
+      ((annotation? x) (symbol? (annotation-expression x)))
+      (else #f))))
+
+(define-syntax id-sym-name
+  (syntax-rules ()
+    ((_ e)
+     (let ((x e))
+       (unannotate (if (syntax-object? x) (syntax-object-expression x) x))))))
+
+(define id-marks
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-marks (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-subst
+  (lambda (id)
+    (if (syntax-object? id)
+        (wrap-subst (syntax-object-wrap id))
+        (wrap-marks top-wrap))))
+
+(define id-sym-name&marks
+  (lambda (x w)
+    (if (syntax-object? x)
+        (values
+          (unannotate (syntax-object-expression x))
+          (join-marks (wrap-marks w) (wrap-marks (syntax-object-wrap x))))
+        (values (unannotate x) (wrap-marks w)))))
+
+;;; syntax object wraps
+
+;;;         <wrap>     ::= ((<mark> ...) . (<subst> ...))
+;;;        <subst>     ::= <ribcage> | <shift>
+;;;      <ribcage>     ::= #((<ex-symname> ...) (<mark> ...) (<label> ...)) ; extensible, for chi-internal/external
+;;;                      | #(#(<symname> ...) #(<mark> ...) #(<label> ...)) ; nonextensible
+;;;   <ex-symname>     ::= <symname> | <import token> | <barrier>
+;;;        <shift>     ::= shift
+;;;      <barrier>     ::= #f                                               ; inserted by import-only
+;;; <import interface> ::= #<import-interface interface new-marks>
+;;;        <token>     ::= <generated id>
+
+(define make-wrap cons)
+(define wrap-marks car)
+(define wrap-subst cdr)
+
+
+(define-syntax empty-wrap (identifier-syntax '(())))
+
+(define-syntax top-wrap (identifier-syntax '((top))))
+
+(define-syntax top-marked?
+  (syntax-rules ()
+    ((_ w) (memq 'top (wrap-marks w)))))
+
+(define-syntax only-top-marked?
+  (syntax-rules ()
+    ((_ id) (same-marks? (wrap-marks (syntax-object-wrap id)) (wrap-marks top-wrap)))))
+
+;;; labels
+
+;;; simple labels must be comparable with "eq?" and distinct from symbols
+;;; and pairs.
+
+;;; indirect labels, which are implemented as pairs, are used to support
+;;; import aliasing for identifiers exported (explictly or implicitly) from
+;;; top-level modules.  chi-external creates an indirect label for each
+;;; defined identifier, import causes the pair to be shared with aliases it
+;;; establishes, and chi-top-module whacks the pair to hold the top-level
+;;; identifier name (symbol) if the id is to be placed at top level, before
+;;; expanding the right-hand sides of the definitions in the module.
+
+(module (gen-indirect-label indirect-label? get-indirect-label set-indirect-label!)
+  (define-structure (indirect-label label))
+  (define gen-indirect-label
+    (lambda ()
+      (make-indirect-label (gen-label))))
+  (define get-indirect-label (lambda (x) (indirect-label-label x)))
+  (define set-indirect-label! (lambda (x v) (set-indirect-label-label! x v))))
+
+(define gen-label
+  (lambda () (string #\i)))
+(define label?
+  (lambda (x)
+    (or (string? x) ; normal lexical labels
+        (symbol? x) ; global labels (symbolic names)
+        (indirect-label? x))))
+
+(define gen-labels
+  (lambda (ls)
+    (if (null? ls)
+        '()
+        (cons (gen-label) (gen-labels (cdr ls))))))
+
+(define-structure (ribcage symnames marks labels))
+(define-structure (top-ribcage key mutable?))
+(define-structure (import-interface interface new-marks))
+(define-structure (env top-ribcage wrap))
+
+;;; Marks must be comparable with "eq?" and distinct from pairs and
+;;; the symbol top.  We do not use integers so that marks will remain
+;;; unique even across file compiles.
+
+(define-syntax the-anti-mark (identifier-syntax #f))
+
+(define anti-mark
+  (lambda (w)
+    (make-wrap (cons the-anti-mark (wrap-marks w))
+               (cons 'shift (wrap-subst w)))))
+
+(define-syntax new-mark
+  (syntax-rules ()
+    ((_) (string #\m))))
+
+(define barrier-marker #f)
+
+;;; make-empty-ribcage and extend-ribcage maintain list-based ribcages for
+;;; internal definitions, in which the ribcages are built incrementally
+(define-syntax make-empty-ribcage
+  (syntax-rules ()
+    ((_) (make-ribcage '() '() '()))))
+
+(define extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks (syntax-object-wrap id))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define import-extend-ribcage!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage new-marks id label)
+    (set-ribcage-symnames! ribcage
+      (cons (unannotate (syntax-object-expression id))
+            (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (join-marks new-marks (wrap-marks (syntax-object-wrap id)))
+            (ribcage-marks ribcage)))
+    (set-ribcage-labels! ribcage
+      (cons label (ribcage-labels ribcage)))))
+
+(define extend-ribcage-barrier!
+ ; must receive ids with complete wraps
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage killer-id)
+    (extend-ribcage-barrier-help! ribcage (syntax-object-wrap killer-id))))
+
+(define extend-ribcage-barrier-help!
+  (lambda (ribcage wrap)
+    (set-ribcage-symnames! ribcage
+      (cons barrier-marker (ribcage-symnames ribcage)))
+    (set-ribcage-marks! ribcage
+      (cons (wrap-marks wrap) (ribcage-marks ribcage)))))
+
+(define extend-ribcage-subst!
+ ; ribcage guaranteed to be list-based
+  (lambda (ribcage import-iface)
+    (set-ribcage-symnames! ribcage
+      (cons import-iface (ribcage-symnames ribcage)))))
+
+(define lookup-import-binding-name
+  (lambda (sym marks token new-marks)
+    (let ((new (get-import-binding sym token)))
+      (and new
+           (let f ((new new))
+             (cond
+               ((pair? new) (or (f (car new)) (f (cdr new))))
+               ((symbol? new)
+                (and (same-marks? marks (join-marks new-marks (wrap-marks top-wrap))) new))
+               ((same-marks? marks (join-marks new-marks (wrap-marks (syntax-object-wrap new)))) new)
+               (else #f)))))))
+  
+(define store-import-binding
+  (lambda (id token new-marks)
+    (define cons-id
+      (lambda (id x)
+        (if (not x) id (cons id x))))
+    (define weed ; remove existing binding for id, if any
+      (lambda (marks x)
+        (if (pair? x)
+            (if (same-marks? (id-marks (car x)) marks)
+                (weed marks (cdr x))
+                (cons-id (car x) (weed marks (cdr x))))
+            (and x (not (same-marks? (id-marks x) marks)) x))))
+    (let ((id (if (null? new-marks)
+                  id
+                  (make-syntax-object (id-sym-name id)
+                    (make-wrap
+                      (join-marks new-marks (id-marks id))
+                      (id-subst id))))))
+      (let ((sym (id-sym-name id)))
+       ; no need to record bindings mapping symbol to self, since this   
+       ; assumed by default.
+        (unless (eq? id sym)
+          (let ((marks (id-marks id)))
+            (let ((x (weed marks (get-import-binding sym token))))
+              (put-import-binding sym token
+                (cons-id
+                  (if (same-marks? marks (wrap-marks top-wrap))
+                     ; need full id only if more than top-marked.
+                      (resolved-id-var-name id)
+                      id)
+                  x)))))))))
+
+;;; make-binding-wrap creates vector-based ribcages
+(define make-binding-wrap
+  (lambda (ids labels w)
+    (if (null? ids)
+        w
+        (make-wrap
+          (wrap-marks w)
+          (cons
+            (let ((labelvec (list->vector labels)))
+              (let ((n (vector-length labelvec)))
+                (let ((symnamevec (make-vector n)) (marksvec (make-vector n)))
+                  (let f ((ids ids) (i 0))
+                    (unless (null? ids)
+                      (let-values (((symname marks) (id-sym-name&marks (car ids) w)))
+                        (vector-set! symnamevec i symname)
+                        (vector-set! marksvec i marks)
+                        (f (cdr ids) (fx+ i 1)))))
+                  (make-ribcage symnamevec marksvec labelvec))))
+            (wrap-subst w))))))
+
+;;; resolved ids contain no unnecessary substitutions or marks.  they are
+;;; used essentially as indirects or aliases in modules interfaces.
+(define make-resolved-id
+  (lambda (fromsym marks tosym)
+    (make-syntax-object fromsym
+      (make-wrap marks
+        (list (make-ribcage (vector fromsym) (vector marks) (vector tosym)))))))
+
+(define id->resolved-id
+  (lambda (id)
+    (let-values (((tosym marks) (id-var-name&marks id empty-wrap)))
+      (unless tosym
+        (syntax-error id "identifier not visible for export"))
+      (make-resolved-id (id-sym-name id) marks tosym))))
+
+(define resolved-id-var-name
+  (lambda (id)
+    (vector-ref
+      (ribcage-labels (car (wrap-subst (syntax-object-wrap id))))
+      0)))
+
+;;; Scheme's append should not copy the first argument if the second is
+;;; nil, but it does, so we define a smart version here.
+(define smart-append
+  (lambda (m1 m2)
+    (if (null? m2)
+        m1
+        (append m1 m2))))
+
+(define join-wraps
+  (lambda (w1 w2)
+    (let ((m1 (wrap-marks w1)) (s1 (wrap-subst w1)))
+      (if (null? m1)
+          (if (null? s1)
+              w2
+              (make-wrap
+                (wrap-marks w2)
+                (join-subst s1 (wrap-subst w2))))
+          (make-wrap
+            (join-marks m1 (wrap-marks w2))
+            (join-subst s1 (wrap-subst w2)))))))
+
+(define join-marks
+  (lambda (m1 m2)
+    (smart-append m1 m2)))
+
+(define join-subst
+  (lambda (s1 s2)
+    (smart-append s1 s2)))
+
+(define same-marks?
+  (lambda (x y)
+    (or (eq? x y)
+        (and (not (null? x))
+             (not (null? y))
+             (eq? (car x) (car y))
+             (same-marks? (cdr x) (cdr y))))))
+
+(define diff-marks
+  (lambda (m1 m2)
+    (let ((n1 (length m1)) (n2 (length m2)))
+      (let f ((n1 n1) (m1 m1))
+        (cond
+          ((fx> n1 n2) (cons (car m1) (f (fx- n1 1) (cdr m1))))
+          ((equal? m1 m2) '())
+          (else (error 'sc-expand
+                  "internal error in diff-marks: ~s is not a tail of ~s"
+                  m1 m2)))))))
+
+(module (top-id-bound-var-name top-id-free-var-name)
+  ;; top-id-bound-var-name is used to look up or establish new top-level
+  ;; substitutions, while top-id-free-var-name is used to look up existing
+  ;; (possibly implicit) substitutions.  Implicit substitutions exist
+  ;; for top-marked names in all environments, but we represent them
+  ;; explicitly only on demand.
+  ;;
+  ;; In both cases, we first look for an existing substitution for sym
+  ;; and the given marks.  If we find one, we return it.  Otherwise, we
+  ;; extend the appropriate top-level environment
+  ;;
+  ;; For top-id-bound-var-name, we extend the environment with a substition
+  ;; keyed by the given marks, so that top-level definitions introduced by
+  ;; a macro are distinct from other top-level definitions for the same
+  ;; name.  For example, if macros a and b both introduce definitions and
+  ;; bound references to identifier x, the two x's should be different,
+  ;; i.e., keyed by their own marks.
+  ;;
+  ;; For top-id-free-var-name, we extend the environment with a substition
+  ;; keyed by the top marks, since top-level free identifier references
+  ;; should refer to the existing implicit (top-marked) substitution.  For
+  ;; example, if macros a and b both introduce free references to identifier
+  ;; x, they should both refer to the same (global, unmarked) x.
+  ;;
+ ;; If the environment is *top*, we map a symbol to itself
+
+ (define leave-implicit? (lambda (token) (eq? token '*top*)))
+
+  (define new-binding
+    (lambda (sym marks token)
+      (let ((loc (if (and (leave-implicit? token)
+                          (same-marks? marks (wrap-marks top-wrap)))
+                     sym
+                     (generate-id sym))))
+        (let ((id (make-resolved-id sym marks loc)))
+          (store-import-binding id token '())
+          (values loc id)))))
+
+  (define top-id-bound-var-name
+   ; should be called only when top-ribcage is mutable
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id)
+             (if (symbol? id) ; symbol iff marks == (wrap-marks top-wrap)
+                 (if (read-only-binding? id)
+                     (new-binding sym marks token)
+                     (values id (make-resolved-id sym marks id)))
+                 (values (resolved-id-var-name id) id))))
+          (else (new-binding sym marks token))))))
+
+  (define top-id-free-var-name
+    (lambda (sym marks top-ribcage)
+      (let ((token (top-ribcage-key top-ribcage)))
+        (cond
+          ((lookup-import-binding-name sym marks token '()) =>
+           (lambda (id) (if (symbol? id) id (resolved-id-var-name id))))
+          ((and (top-ribcage-mutable? top-ribcage)
+                (same-marks? marks (wrap-marks top-wrap)))
+           (let-values (((sym id) (new-binding sym (wrap-marks top-wrap) token)))
+             sym))
+          (else #f))))))
+
+(define id-var-name-loc&marks
+  (lambda (id w)
+    (define search
+      (lambda (sym subst marks)
+        (if (null? subst)
+            (values #f marks)
+            (let ((fst (car subst)))
+               (cond
+                 ((eq? fst 'shift) (search sym (cdr subst) (cdr marks)))
+                 ((ribcage? fst)
+                  (let ((symnames (ribcage-symnames fst)))
+                    (if (vector? symnames)
+                        (search-vector-rib sym subst marks symnames fst)
+                        (search-list-rib sym subst marks symnames fst))))
+                 ((top-ribcage? fst)
+                  (cond
+                    ((top-id-free-var-name sym marks fst) =>
+                     (lambda (var-name) (values var-name marks)))
+                    (else (search sym (cdr subst) marks))))
+                 (else
+                  (error 'sc-expand
+                    "internal error in id-var-name-loc&marks: improper subst ~s"
+                    subst)))))))
+    (define search-list-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let f ((symnames symnames) (i 0))
+          (if (null? symnames)
+              (search sym (cdr subst) marks)
+              (let ((x (car symnames)))
+                (cond
+                  ((and (eq? x sym)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values (list-ref (ribcage-labels ribcage) i) marks))
+                  ((import-interface? x)
+                   (let ((iface (import-interface-interface x))
+                         (new-marks (import-interface-new-marks x)))
+                     (cond
+                       ((interface-token iface) =>
+                        (lambda (token)
+                          (cond
+                            ((lookup-import-binding-name sym marks token new-marks) =>
+                             (lambda (id)
+                               (values
+                                 (if (symbol? id) id (resolved-id-var-name id))
+                                 marks)))
+                            (else (f (cdr symnames) i)))))
+                       (else
+                        (let* ((ie (interface-exports iface))
+                               (n (vector-length ie)))
+                          (let g ((j 0))
+                            (if (fx= j n)
+                                (f (cdr symnames) i)
+                                (let ((id (vector-ref ie j)))
+                                  (let ((id.sym (id-sym-name id))
+                                        (id.marks (join-marks new-marks (id-marks id))))
+                                    (if (help-bound-id=? id.sym id.marks sym marks)
+                                        (values (lookup-import-label id) marks)
+                                        (g (fx+ j 1))))))))))))
+                  ((and (eq? x barrier-marker)
+                        (same-marks? marks (list-ref (ribcage-marks ribcage) i)))
+                   (values #f marks))
+                  (else (f (cdr symnames) (fx+ i 1)))))))))
+    (define search-vector-rib
+      (lambda (sym subst marks symnames ribcage)
+        (let ((n (vector-length symnames)))
+          (let f ((i 0))
+            (cond
+              ((fx= i n) (search sym (cdr subst) marks))
+              ((and (eq? (vector-ref symnames i) sym)
+                    (same-marks? marks (vector-ref (ribcage-marks ribcage) i)))
+               (values (vector-ref (ribcage-labels ribcage) i) marks))
+              (else (f (fx+ i 1))))))))
+    (cond
+      ((symbol? id) (search id (wrap-subst w) (wrap-marks w)))
+      ((syntax-object? id)
+       (let ((sym (unannotate (syntax-object-expression id)))
+             (w1 (syntax-object-wrap id)))
+         (let-values (((name marks) (search sym (wrap-subst w)
+                                      (join-marks
+                                        (wrap-marks w)
+                                        (wrap-marks w1)))))
+           (if name
+               (values name marks)
+               (search sym (wrap-subst w1) marks)))))
+      ((annotation? id) (search (unannotate id) (wrap-subst w) (wrap-marks w)))
+      (else (error-hook 'id-var-name "invalid id" id)))))
+
+(define id-var-name&marks
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (values (if (indirect-label? label) (get-indirect-label label) label) marks))))
+
+(define id-var-name-loc
+ ; this version doesn't follow indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      label)))
+
+(define id-var-name
+ ; this version follows indirect labels
+  (lambda (id w)
+    (let-values (((label marks) (id-var-name-loc&marks id w)))
+      (if (indirect-label? label) (get-indirect-label label) label))))
+
+;;; free-id=? must be passed fully wrapped ids since (free-id=? x y)
+;;; may be true even if (free-id=? (wrap x w) (wrap y w)) is not.
+
+(define free-id=?
+  (lambda (i j)
+    (and (eq? (id-sym-name i) (id-sym-name j)) ; accelerator
+         (eq? (id-var-name i empty-wrap) (id-var-name j empty-wrap)))))
+
+(define literal-id=?
+  (lambda (id literal)
+    (and (eq? (id-sym-name id) (id-sym-name literal))
+         (let ((n-id (id-var-name id empty-wrap))
+               (n-literal (id-var-name literal empty-wrap)))
+           (or (eq? n-id n-literal)
+               (and (or (not n-id) (symbol? n-id))
+                    (or (not n-literal) (symbol? n-literal))))))))
+
+;;; bound-id=? may be passed unwrapped (or partially wrapped) ids as
+;;; long as the missing portion of the wrap is common to both of the ids
+;;; since (bound-id=? x y) iff (bound-id=? (wrap x w) (wrap y w))
+
+(define help-bound-id=?
+  (lambda (i.sym i.marks j.sym j.marks)
+    (and (eq? i.sym j.sym)
+         (same-marks? i.marks j.marks))))
+   
+(define bound-id=?
+  (lambda (i j)
+    (help-bound-id=? (id-sym-name i) (id-marks i) (id-sym-name j) (id-marks j))))
+
+;;; "valid-bound-ids?" returns #t if it receives a list of distinct ids.
+;;; valid-bound-ids? may be passed unwrapped (or partially wrapped) ids
+;;; as long as the missing portion of the wrap is common to all of the
+;;; ids.
+
+(define valid-bound-ids?
+  (lambda (ids)
+     (and (let all-ids? ((ids ids))
+            (or (null? ids)
+                (and (id? (car ids))
+                     (all-ids? (cdr ids)))))
+          (distinct-bound-ids? ids))))
+
+;;; distinct-bound-ids? expects a list of ids and returns #t if there are
+;;; no duplicates.  It is quadratic on the length of the id list; long
+;;; lists could be sorted to make it more efficient.  distinct-bound-ids?
+;;; may be passed unwrapped (or partially wrapped) ids as long as the
+;;; missing portion of the wrap is common to all of the ids.
+
+(define distinct-bound-ids?
+  (lambda (ids)
+    (let distinct? ((ids ids))
+      (or (null? ids)
+          (and (not (bound-id-member? (car ids) (cdr ids)))
+               (distinct? (cdr ids)))))))
+
+(define invalid-ids-error
+ ; find first bad one and complain about it
+  (lambda (ids exp class)
+    (let find ((ids ids) (gooduns '()))
+      (if (null? ids)
+          (syntax-error exp) ; shouldn't happen
+          (if (id? (car ids))
+              (if (bound-id-member? (car ids) gooduns)
+                  (syntax-error (car ids) "duplicate " class)
+                  (find (cdr ids) (cons (car ids) gooduns)))
+              (syntax-error (car ids) "invalid " class))))))
+
+(define bound-id-member?
+   (lambda (x list)
+      (and (not (null? list))
+           (or (bound-id=? x (car list))
+               (bound-id-member? x (cdr list))))))
+
+;;; wrapping expressions and identifiers
+
+(define wrap
+  (lambda (x w)
+    (cond
+      ((and (null? (wrap-marks w)) (null? (wrap-subst w))) x)
+      ((syntax-object? x)
+       (make-syntax-object
+         (syntax-object-expression x)
+         (join-wraps w (syntax-object-wrap x))))
+      ((null? x) x)
+      (else (make-syntax-object x w)))))
+
+(define source-wrap
+  (lambda (x w ae)
+    (wrap (if (annotation? ae)
+              (begin
+                (unless (eq? (annotation-expression ae) x)
+                  (error 'sc-expand "internal error in source-wrap: ae/x mismatch"))
+                ae)
+              x)
+          w)))
+
+;;; expanding
+
+(define chi-when-list
+  (lambda (when-list w)
+    ; when-list is syntax'd version of list of situations
+    (map (lambda (x)
+           (cond
+             ((literal-id=? x (syntax compile)) 'compile)
+             ((literal-id=? x (syntax load)) 'load)
+             ((literal-id=? x (syntax visit)) 'visit)
+             ((literal-id=? x (syntax revisit)) 'revisit)
+             ((literal-id=? x (syntax eval)) 'eval)
+             (else (syntax-error (wrap x w) "invalid eval-when situation"))))
+         when-list)))
+
+;;; syntax-type returns five values: type, value, e, w, and ae.  The first
+;;; two are described in the table below.
+;;;
+;;;    type                   value         explanation
+;;;    -------------------------------------------------------------------
+;;;    alias                  none          alias keyword
+;;;    alias-form             none          alias expression
+;;;    begin                  none          begin keyword
+;;;    begin-form             none          begin expression
+;;;    call                   none          any other call
+;;;    constant               none          self-evaluating datum
+;;;    core                   procedure     core form (including singleton)
+;;;    define                 none          define keyword
+;;;    define-form            none          variable definition
+;;;    define-syntax          none          define-syntax keyword
+;;;    define-syntax-form     none          syntax definition
+;;;    displaced-lexical      none          displaced lexical identifier
+;;;    eval-when              none          eval-when keyword
+;;;    eval-when-form         none          eval-when form
+;;;    global                 name          global variable reference
+;;;    $import                none          $import keyword
+;;;    $import-form           none          $import form
+;;;    lexical                name          lexical variable reference
+;;;    lexical-call           name          call to lexical variable
+;;;    local-syntax           rec?          letrec-syntax/let-syntax keyword
+;;;    local-syntax-form      rec?          syntax definition
+;;;    meta                   none          meta keyword
+;;;    meta-form              none          meta form
+;;;    meta-variable          name          meta variable
+;;;    $module                none          $module keyword
+;;;    $module-form           none          $module definition
+;;;    syntax                 level         pattern variable
+;;;    other                  none          anything else
+;;;
+;;; For all forms, e is the form, w is the wrap for e. and ae is the
+;;; (possibly) source-annotated form.
+;;;
+;;; syntax-type expands macros and unwraps as necessary to get to
+;;; one of the forms above.
+
+(define syntax-type
+  (lambda (e r w ae rib)
+    (cond
+      ((symbol? e)
+       (let* ((n (id-var-name e w))
+              (b (lookup n r))
+              (type (binding-type b)))
+         (case type
+           ((macro macro!) (syntax-type (chi-macro (binding-value b) e r w ae rib) r empty-wrap #f rib))
+           (else (values type (binding-value b) e w ae)))))
+      ((pair? e)
+       (let ((first (car e)))
+         (if (id? first)
+             (let* ((n (id-var-name first w))
+                    (b (lookup n r))
+                    (type (binding-type b)))
+               (case type
+                 ((lexical) (values 'lexical-call (binding-value b) e w ae))
+                 ((macro macro!)
+                  (syntax-type (chi-macro (binding-value b) e r w ae rib)
+                    r empty-wrap #f rib))
+                 ((core) (values type (binding-value b) e w ae))
+                 ((begin) (values 'begin-form #f e w ae))
+                 ((alias) (values 'alias-form #f e w ae))
+                 ((define) (values 'define-form #f e w ae))
+                 ((define-syntax) (values 'define-syntax-form #f e w ae))
+                 ((set!) (chi-set! e r w ae rib))
+                 (($module-key) (values '$module-form #f e w ae))
+                 (($import) (values '$import-form #f e w ae))
+                 ((eval-when) (values 'eval-when-form #f e w ae))
+                 ((meta) (values 'meta-form #f e w ae))
+                 ((local-syntax)
+                  (values 'local-syntax-form (binding-value b) e w ae))
+                 (else (values 'call #f e w ae))))
+             (values 'call #f e w ae))))
+      ((syntax-object? e)
+       (syntax-type (syntax-object-expression e)
+                    r
+                    (join-wraps w (syntax-object-wrap e))
+                    #f rib))
+      ((annotation? e)
+       (syntax-type (annotation-expression e) r w e rib))
+      ((self-evaluating? e) (values 'constant #f e w ae))
+      (else (values 'other #f e w ae)))))
+
+(define chi-top*
+  (lambda (e r w ctem rtem meta? top-ribcage)
+    (let ((meta-residuals '()))
+      (define meta-residualize!
+        (lambda (x)
+          (set! meta-residuals
+            (cons x meta-residuals))))
+      (let ((e (chi-top e r w ctem rtem meta? top-ribcage meta-residualize! #f)))
+        (build-sequence no-source
+          (reverse (cons e meta-residuals)))))))
+
+(define chi-top-sequence
+  (lambda (body r w ae ctem rtem meta? ribcage meta-residualize!)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi-top (car body) r w ctem rtem meta? ribcage meta-residualize! #f)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi-top
+  (lambda (e r w ctem rtem meta? top-ribcage meta-residualize! meta-seen?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source top-ribcage)))
+      (case type
+        ((begin-form)
+         (let ((forms (parse-begin e w ae #t)))
+           (if (null? forms)
+               (chi-void)
+               (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!))))
+        ((local-syntax-form)
+         (let-values (((forms r mr w ae) (chi-local-syntax value e r r w ae)))
+          ; mr should be same as r here
+           (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))
+        ((eval-when-form)
+         (let-values (((when-list forms) (parse-eval-when e w ae)))
+           (let ((ctem (update-mode-set when-list ctem))
+                 (rtem (update-mode-set when-list rtem)))
+             (if (and (null? ctem) (null? rtem))
+                 (chi-void)
+                 (chi-top-sequence forms r w ae ctem rtem meta? top-ribcage meta-residualize!)))))
+        ((meta-form) (chi-top (parse-meta e w ae) r w ctem rtem #t top-ribcage meta-residualize! #t))
+        ((define-syntax-form)
+         (let-values (((id rhs w) (parse-define-syntax e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       bound-id
+                       (chi rhs r r w #t)
+                       (top-ribcage-key top-ribcage)))))))))
+        ((define-form)
+         (let-values (((id rhs w) (parse-define e w ae)))
+           (let ((id (wrap id w)))
+             (when (displaced-lexical? id r) (displaced-lexical-error id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap id)) top-ribcage)))
+                 (unless (eq? (id-var-name id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (if meta?
+                     (ct-eval/residualize2 ctem
+                       (lambda ()
+                         (build-sequence no-source
+                           (list
+                             (build-cte-install bound-id
+                               (build-data no-source (make-binding 'meta-variable valsym))
+                               (top-ribcage-key top-ribcage))
+                             (build-global-definition ae valsym (chi rhs r r w #t))))))
+                    ; make sure compile-time definitions occur before we
+                    ; expand the run-time code
+                     (let ((x (ct-eval/residualize2 ctem
+                                (lambda ()
+                                  (build-cte-install
+                                    bound-id
+                                    (build-data no-source (make-binding 'global valsym))
+                                    (top-ribcage-key top-ribcage))))))
+                       (build-sequence no-source
+                         (list
+                           x
+                           (rt-eval/residualize rtem
+                             (lambda ()
+                               (build-global-definition ae valsym (chi rhs r r w #f)))))))))
+             ))))
+        (($module-form)
+         (let ((ribcage (make-empty-ribcage)))
+           (let-values (((orig id exports forms)
+                         (parse-module e w ae
+                           (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))))
+             (when (displaced-lexical? id r) (displaced-lexical-error (wrap id w)))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error orig
+                 "invalid definition in read-only environment"))
+             (chi-top-module orig r r top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!))))
+        (($import-form)
+         (let-values (((orig only? mid) (parse-import e w ae)))
+           (unless (top-ribcage-mutable? top-ribcage)
+             (syntax-error orig
+               "invalid definition in read-only environment"))
+           (ct-eval/residualize2 ctem
+             (lambda ()
+               (let ((binding (lookup (id-var-name mid empty-wrap) null-env)))
+                 (case (binding-type binding)
+                   (($module) (do-top-import only? top-ribcage mid (interface-token (binding-value binding))))
+                   ((displaced-lexical) (displaced-lexical-error mid))
+                   (else (syntax-error mid "unknown module"))))))))
+        ((alias-form)
+         (let-values (((new-id old-id) (parse-alias e w ae)))
+           (let ((new-id (wrap new-id w)))
+             (when (displaced-lexical? new-id r) (displaced-lexical-error new-id))
+             (unless (top-ribcage-mutable? top-ribcage)
+               (syntax-error (source-wrap e w ae)
+                 "invalid definition in read-only environment"))
+             (let ((sym (id-sym-name new-id)))
+               (let-values (((valsym bound-id) (top-id-bound-var-name sym (wrap-marks (syntax-object-wrap new-id)) top-ribcage)))
+                 (unless (eq? (id-var-name new-id empty-wrap) valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "definition not permitted"))
+                 (when (read-only-binding? valsym)
+                   (syntax-error (source-wrap e w ae)
+                     "invalid definition of read-only identifier"))
+                 (ct-eval/residualize2 ctem
+                   (lambda ()
+                     (build-cte-install
+                       (make-resolved-id sym (wrap-marks (syntax-object-wrap new-id)) (id-var-name old-id w))
+                       (build-data no-source (make-binding 'do-alias #f))
+                       (top-ribcage-key top-ribcage)))))))))
+        (else
+         (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+         (if meta?
+             (let ((x (chi-expr type value e r r w ae #t)))
+               (top-level-eval-hook x)
+               (ct-eval/residualize3 ctem void (lambda () x)))
+             (rt-eval/residualize rtem
+               (lambda ()
+                 (chi-expr type value e r r w ae #f)))))))))
+
+(define flatten-exports
+  (lambda (exports)
+    (let loop ((exports exports) (ls '()))
+      (if (null? exports)
+          ls
+          (loop (cdr exports)
+                (if (pair? (car exports))
+                    (loop (car exports) ls)
+                    (cons (car exports) ls)))))))
+
+
+(define-structure (interface marks exports token))
+
+;; leaves interfaces unresolved so that indirect labels can be followed.
+;; (can't resolve until indirect labels have their final value)
+(define make-unresolved-interface
+ ; trim out implicit exports
+  (lambda (mid exports)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (if (pair? x) (car x) x)) exports))
+      #f)))
+
+(define make-resolved-interface
+ ; trim out implicit exports & resolve others to actual top-level symbol
+  (lambda (mid exports token)
+    (make-interface
+      (wrap-marks (syntax-object-wrap mid))
+      (list->vector (map (lambda (x) (id->resolved-id (if (pair? x) (car x) x))) exports))
+      token)))
+
+(define-structure (module-binding type id label imps val exported))
+(define create-module-binding
+  (lambda (type id label imps val)
+    (make-module-binding type id label imps val #f)))
+
+;;; frobs represent body forms
+(define-structure (frob e meta?))
+
+(define chi-top-module
+  (lambda (orig r mr top-ribcage ribcage ctem rtem meta? id exports forms meta-residualize!)
+    (let ((fexports (flatten-exports exports)))
+      (let-values (((r mr bindings inits)
+                    (chi-external ribcage orig
+                      (map (lambda (d) (make-frob d meta?)) forms) r mr ctem exports fexports
+                      meta-residualize!)))
+       ; identify exported identifiers, create ctdefs
+        (let process-exports ((fexports fexports) (ctdefs (lambda () '())))
+          (if (null? fexports)
+             ; remaining bindings are either identified global vars,
+             ; local vars, or local compile-time entities
+             ; dts: type (local/global)
+             ; dvs & des: define lhs & rhs
+              (let process-locals ((bs bindings) (r r) (dts '()) (dvs '()) (des '()))
+                (if (null? bs)
+                    (let ((des (chi-frobs des r mr #f))
+                          (inits (chi-frobs inits r mr #f)))
+                      (build-sequence no-source
+                        (append
+                         ; we wait to establish global compile-time definitions so that
+                         ; expansion of des use local versions of modules and macros
+                         ; in case ctem tells us not to eval ctdefs now.  this means that
+                         ; local code can use exported compile-time values (modules, macros,
+                         ; meta variables) just as it can unexported ones.
+                          (ctdefs)
+                          (list
+                            (ct-eval/residualize2 ctem
+                              (lambda ()
+                                (let ((sym (id-sym-name id)))
+                                  (let* ((token (generate-id sym))
+                                         (b (build-data no-source
+                                              (make-binding '$module
+                                                (make-resolved-interface id exports token)))))
+                                    (let-values (((valsym bound-id)
+                                                  (top-id-bound-var-name sym
+                                                    (wrap-marks (syntax-object-wrap id))
+                                                    top-ribcage)))
+                                      (unless (eq? (id-var-name id empty-wrap) valsym)
+                                        (syntax-error orig
+                                          "definition not permitted"))
+                                      (when (read-only-binding? valsym)
+                                        (syntax-error orig
+                                          "invalid definition of read-only identifier"))
+                                      (build-cte-install bound-id b
+                                        (top-ribcage-key top-ribcage)))))))
+                            (rt-eval/residualize rtem
+                              (lambda ()
+                                (build-top-module no-source dts dvs des
+                                  (if (null? inits)
+                                      (chi-void)
+                                      (build-sequence no-source
+                                        (append inits (list (chi-void))))))))))))
+                    (let ((b (car bs)) (bs (cdr bs)))
+                      (let ((t (module-binding-type b)))
+                        (case (module-binding-type b)
+                          ((define-form)
+                           (let ((label (get-indirect-label (module-binding-label b))))
+                             (if (module-binding-exported b)
+                                 (let ((var (module-binding-id b)))
+                                   (process-locals bs r (cons 'global dts) (cons label dvs)
+                                     (cons (module-binding-val b) des)))
+                                 (let ((var (gen-var (module-binding-id b))))
+                                   (process-locals bs
+                                    ; add lexical bindings only to run-time environment
+                                     (extend-env label (make-binding 'lexical var) r)
+                                     (cons 'local dts) (cons var dvs)
+                                     (cons (module-binding-val b) des))))))
+                          ((ctdefine-form define-syntax-form $module-form alias-form) (process-locals bs r dts dvs des))
+                          (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))))
+              (let ((id (car fexports)) (fexports (cdr fexports)))
+                (let loop ((bs bindings))
+                  (if (null? bs)
+                     ; must be rexport from an imported module
+                      (process-exports fexports ctdefs)
+                      (let ((b (car bs)) (bs (cdr bs)))
+                       ; following formerly used bound-id=?, but free-id=? can prevent false positives
+                       ; and is okay since the substitutions have already been applied
+                        (if (free-id=? (module-binding-id b) id)
+                            (if (module-binding-exported b)
+                                (process-exports fexports ctdefs)
+                                (let* ((t (module-binding-type b))
+                                       (label (module-binding-label b))
+                                       (imps (module-binding-imps b))
+                                       (fexports (append imps fexports)))
+                                  (set-module-binding-exported! b #t)
+                                  (case t
+                                    ((define-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (set-indirect-label! label sym)
+                                       (process-exports fexports ctdefs)))
+                                    ((ctdefine-form)
+                                     (let ((b (module-binding-val b)))
+                                       (process-exports fexports
+                                         (lambda ()
+                                           (let ((sym (binding-value b)))
+                                             (set-indirect-label! label sym)
+                                             (cons (ct-eval/residualize3 ctem
+                                                     (lambda () (put-cte-hook sym b))
+                                                     (lambda () (build-cte-install sym (build-data no-source b) #f)))
+                                                   (ctdefs)))))))
+                                    ((define-syntax-form)
+                                     (let ((sym (generate-id (id-sym-name id))))
+                                       (process-exports fexports
+                                         (lambda () 
+                                           (let ((local-label (get-indirect-label label)))
+                                             (set-indirect-label! label sym)
+                                             (cons
+                                               (ct-eval/residualize3 ctem
+                                                 (lambda () (put-cte-hook sym (car (module-binding-val b))))
+                                                 (lambda () (build-cte-install sym (cdr (module-binding-val b)) #f)))
+                                               (ctdefs)))))))
+                                    (($module-form)
+                                     (let ((sym (generate-id (id-sym-name id)))
+                                           (exports (module-binding-val b)))
+                                       (process-exports (append (flatten-exports exports) fexports)
+                                         (lambda ()
+                                           (set-indirect-label! label sym)
+                                           (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                             (let ((x (make-binding '$module (make-resolved-interface id exports sym))))
+                                               (cons (ct-eval/residualize3 ctem
+                                                       (lambda () (put-cte-hook sym x))
+                                                       (lambda () (build-cte-install sym (build-data no-source x) #f)))
+                                                     rest)))))))
+                                    ((alias-form)
+                                     (process-exports
+                                       fexports
+                                       (lambda ()
+                                         (let ((rest (ctdefs))) ; set indirect labels before resolving
+                                           (when (indirect-label? label)
+                                             (unless (symbol? (get-indirect-label label))
+                                               (syntax-error (module-binding-id b) "unexported target of alias")))
+                                           rest))))
+                                    (else (error 'sc-expand-internal "unexpected module binding type ~s" t)))))
+                            (loop bs))))))))))))
+
+(define id-set-diff
+  (lambda (exports defs)
+    (cond
+      ((null? exports) '())
+      ((bound-id-member? (car exports) defs) (id-set-diff (cdr exports) defs))
+      (else (cons (car exports) (id-set-diff (cdr exports) defs))))))
+
+(define check-module-exports
+  ; After processing the definitions of a module this is called to verify that the
+  ; module has defined or imported each exported identifier.  Because ids in fexports are
+  ; wrapped with the given ribcage, they will contain substitutions for anything defined
+  ; or imported here.  These subsitutions can be used by do-import! and do-import-top! to
+  ; provide access to reexported bindings, for example.
+  (lambda (source-exp fexports ids)
+    (define defined?
+      (lambda (e ids)
+        (ormap (lambda (x)
+                 (if (import-interface? x)
+                     (let ((x.iface (import-interface-interface x))
+                           (x.new-marks (import-interface-new-marks x)))
+                       (cond
+                         ((interface-token x.iface) =>
+                          (lambda (token)
+                            (lookup-import-binding-name (id-sym-name e) (id-marks e) token x.new-marks)))
+                         (else
+                          (let ((v (interface-exports x.iface)))
+                            (let lp ((i (fx- (vector-length v) 1)))
+                              (and (fx>= i 0)
+                                   (or (let ((id (vector-ref v i)))
+                                         (help-bound-id=?
+                                           (id-sym-name id)
+                                           (join-marks x.new-marks (id-marks id))
+                                           (id-sym-name e) (id-marks e)))
+                                       (lp (fx- i 1)))))))))
+                     (bound-id=? e x)))
+               ids)))
+    (let loop ((fexports fexports) (missing '()))
+      (if (null? fexports)
+          (unless (null? missing)
+            (syntax-error (car missing)
+              (if (fx= (length missing) 1)
+                  "missing definition for export"
+                  "missing definition for multiple exports, including")))
+          (let ((e (car fexports)) (fexports (cdr fexports)))
+            (if (defined? e ids)
+                (loop fexports missing)
+                (loop fexports (cons e missing))))))))
+
+(define check-defined-ids
+  (lambda (source-exp ls)
+    (define vfold
+      (lambda (v p cls)
+        (let ((len (vector-length v)))
+          (let lp ((i 0) (cls cls))
+            (if (fx= i len)
+                cls
+                (lp (fx+ i 1) (p (vector-ref v i) cls)))))))
+    (define conflicts
+      (lambda (x y cls)
+        (if (import-interface? x)
+            (let ((x.iface (import-interface-interface x))
+                  (x.new-marks (import-interface-new-marks x)))
+              (if (import-interface? y)
+                  (let ((y.iface (import-interface-interface y))
+                        (y.new-marks (import-interface-new-marks y)))
+                    (let ((xe (interface-exports x.iface)) (ye (interface-exports y.iface)))
+                      (if (fx> (vector-length xe) (vector-length ye))
+                          (vfold ye
+                            (lambda (id cls)
+                              (id-iface-conflicts id y.new-marks x.iface x.new-marks cls)) cls)
+                          (vfold xe
+                            (lambda (id cls)
+                              (id-iface-conflicts id x.new-marks y.iface y.new-marks cls)) cls))))
+                  (id-iface-conflicts y '() x.iface x.new-marks cls)))
+            (if (import-interface? y)
+                (let ((y.iface (import-interface-interface y))
+                      (y.new-marks (import-interface-new-marks y)))
+                  (id-iface-conflicts x '() y.iface y.new-marks cls))
+                (if (bound-id=? x y) (cons x cls) cls)))))
+     (define id-iface-conflicts
+       (lambda (id id.new-marks iface iface.new-marks cls)
+         (let ((id.sym (id-sym-name id))
+               (id.marks (join-marks id.new-marks (id-marks id))))
+           (cond
+             ((interface-token iface) =>
+              (lambda (token)
+                (if (lookup-import-binding-name id.sym id.marks token iface.new-marks)
+                    (cons id cls)
+                    cls)))
+             (else
+              (vfold (interface-exports iface)
+                     (lambda (*id cls)
+                       (let ((*id.sym (id-sym-name *id))
+                             (*id.marks (join-marks iface.new-marks (id-marks *id))))
+                         (if (help-bound-id=? *id.sym *id.marks id.sym id.marks)
+                             (cons *id cls)
+                             cls)))
+                     cls))))))
+     (unless (null? ls)
+       (let lp ((x (car ls)) (ls (cdr ls)) (cls '()))
+         (if (null? ls)
+             (unless (null? cls)
+               (let ((cls (syntax-object->datum cls)))
+                 (syntax-error source-exp "duplicate definition for "
+                  (symbol->string (car cls))
+                   " in")))
+             (let lp2 ((ls2 ls) (cls cls))
+               (if (null? ls2)
+                   (lp (car ls) (cdr ls) cls)
+                   (lp2 (cdr ls2) (conflicts x (car ls2) cls)))))))))
+
+(define chi-external
+  (lambda (ribcage source-exp body r mr ctem exports fexports meta-residualize!)
+    (define return
+      (lambda (r mr bindings ids inits)
+        (check-defined-ids source-exp ids)
+        (check-module-exports source-exp fexports ids)
+        (values r mr bindings inits)))
+    (define get-implicit-exports
+      (lambda (id)
+        (let f ((exports exports))
+          (if (null? exports)
+              '()
+              (if (and (pair? (car exports)) (bound-id=? id (caar exports)))
+                  (flatten-exports (cdar exports))
+                  (f (cdr exports)))))))
+    (define update-imp-exports
+      (lambda (bindings exports)
+        (let ((exports (map (lambda (x) (if (pair? x) (car x) x)) exports)))
+          (map (lambda (b)
+                 (let ((id (module-binding-id b)))
+                   (if (not (bound-id-member? id exports))
+                       b
+                       (create-module-binding
+                         (module-binding-type b)
+                         id
+                         (module-binding-label b)
+                         (append (get-implicit-exports id) (module-binding-imps b))
+                         (module-binding-val b)))))
+               bindings))))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (bindings '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr bindings ids inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (sym (generate-id (id-sym-name id)))
+                          (imps (get-implicit-exports id)))
+                     (extend-ribcage! ribcage id label)
+                     (cond
+                       (meta?
+                        (let* ((sym (generate-id (id-sym-name id)))
+                               (b (make-binding 'meta-variable sym)))
+                         ; add meta bindings only to meta environment
+                          (let ((mr (extend-env (get-indirect-label label) b mr)))
+                            (let ((exp (chi rhs mr mr w #t)))
+                              (define-top-level-value-hook sym (top-level-eval-hook exp))
+                              (meta-residualize!
+                                (ct-eval/residualize3 ctem
+                                  void
+                                  (lambda () (build-global-definition no-source sym exp))))
+                              (parse (cdr body) r mr
+                                (cons id ids)
+                                (cons (create-module-binding 'ctdefine-form id label imps b) bindings)
+                                inits
+                                #f)))))
+                       (else
+                        (parse (cdr body) r mr
+                          (cons id ids)
+                          (cons (create-module-binding type id label
+                                  imps (make-frob (wrap rhs w) meta?))
+                                bindings)
+                          inits
+                          #f))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let* ((id (wrap id w))
+                          (label (gen-indirect-label))
+                          (imps (get-implicit-exports id))
+                          (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((l (get-indirect-label label)) (b (defer-or-eval-transformer top-level-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env l b r)
+                         (extend-env l b mr)
+                         (cons id ids)
+                         (cons (create-module-binding type id label imps (cons b exp))
+                               bindings)
+                         inits
+                         #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id *exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *bindings *inits)
+                                   (chi-external *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr ctem *exports (flatten-exports *exports) meta-residualize!)))
+                       (let ((iface (make-unresolved-interface id *exports))
+                             (bindings (append *bindings bindings))
+                             (inits (append inits *inits))
+                             (label (gen-indirect-label))
+                             (imps (get-implicit-exports id)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((l (get-indirect-label label)) (b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env l b r)
+                             (extend-env l b mr)
+                             (cons id ids)
+                             (cons (create-module-binding type id label imps *exports) bindings)
+                             inits
+                             #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr
+                             (cons import-iface ids)
+                             (update-imp-exports bindings (vector->list (interface-exports iface)))
+                             inits
+                             #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+               ((alias-form)
+                (let-values (((new-id old-id) (parse-alias e w ae)))
+                  (let* ((new-id (wrap new-id w))
+                         (label (id-var-name-loc old-id w))
+                         (imps (get-implicit-exports new-id)))
+                    (extend-ribcage! ribcage new-id label)
+                    (parse (cdr body) r mr
+                      (cons new-id ids)
+                      (cons (create-module-binding type new-id label imps #f)
+                            bindings)
+                      inits
+                      #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids bindings inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                    (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                               (let f ((forms forms))
+                                 (if (null? forms)
+                                     (cdr body)
+                                     (cons (make-frob (wrap (car forms) w) meta?)
+                                           (f (cdr forms)))))
+                               (cdr body))
+                      r mr ids bindings inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids bindings inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids bindings inits #f)))
+                (else ; found an init expression
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr bindings ids (append inits body))
+                       (begin
+                        ; expand and eval meta inits for effect only
+                         (let ((x (chi-meta-frob (car body) mr)))
+                           (top-level-eval-hook x)
+                           (meta-residualize! (ct-eval/residualize3 ctem void (lambda () x))))
+                         (f (cdr body)))))))))))))
+
+(define vmap
+  (lambda (fn v)
+    (do ((i (fx- (vector-length v) 1) (fx- i 1))
+         (ls '() (cons (fn (vector-ref v i)) ls)))
+        ((fx< i 0) ls))))
+
+(define vfor-each
+  (lambda (fn v)
+    (let ((len (vector-length v)))
+      (do ((i 0 (fx+ i 1)))
+          ((fx= i len))
+        (fn (vector-ref v i))))))
+
+(define do-top-import
+  (lambda (import-only? top-ribcage mid token)
+   ; silently treat import-only like regular import at top level
+    (build-cte-install mid
+      (build-data no-source
+        (make-binding 'do-import token))
+      (top-ribcage-key top-ribcage))))
+
+(define update-mode-set
+  (let ((table
+         '((L (load . L) (compile . C) (visit . V) (revisit . R) (eval . -))
+           (C (load . -) (compile . -) (visit . -) (revisit . -) (eval . C))
+           (V (load . V) (compile . C) (visit . V) (revisit . -) (eval . -))
+           (R (load . R) (compile . C) (visit . -) (revisit . R) (eval . -))
+           (E (load . -) (compile . -) (visit . -) (revisit . -) (eval . E)))))
+    (lambda (when-list mode-set)
+      (define remq
+        (lambda (x ls)
+          (if (null? ls)
+              '()
+              (if (eq? (car ls) x)
+                  (remq x (cdr ls))
+                  (cons (car ls) (remq x (cdr ls)))))))
+      (remq '-
+        (apply append
+          (map (lambda (m)
+                 (let ((row (cdr (assq m table))))
+                   (map (lambda (s) (cdr (assq s row)))
+                        when-list)))
+               mode-set))))))
+
+(define initial-mode-set
+  (lambda (when-list compiling-a-file)
+    (apply append
+      (map (lambda (s)
+             (if compiling-a-file
+                 (case s
+                   ((compile) '(C))
+                   ((load) '(L))
+                   ((visit) '(V))
+                   ((revisit) '(R))
+                   (else '()))
+                 (case s
+                   ((eval) '(E))
+                   (else '()))))
+           when-list))))
+
+(define rt-eval/residualize
+  (lambda (rtem thunk)
+    (if (memq 'E rtem)
+        (thunk)
+        (let ((thunk (if (memq 'C rtem)
+                         (let ((x (thunk)))
+                           (top-level-eval-hook x)
+                           (lambda () x))
+                         thunk)))
+          (if (memq 'V rtem)
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (thunk) ; visit-revisit
+                  (build-visit-only (thunk)))
+              (if (or (memq 'L rtem) (memq 'R rtem))
+                  (build-revisit-only (thunk))
+                  (chi-void)))))))
+
+(define ct-eval/residualize2
+  (lambda (ctem thunk)
+    (let ((t #f))
+      (ct-eval/residualize3 ctem
+        (lambda ()
+          (unless t (set! t (thunk)))
+          (top-level-eval-hook t))
+        (lambda () (or t (thunk)))))))
+
+(define ct-eval/residualize3
+  (lambda (ctem eval-thunk residualize-thunk)
+    (if (memq 'E ctem)
+        (begin (eval-thunk) (chi-void))
+        (begin
+          (when (memq 'C ctem) (eval-thunk))
+          (if (memq 'R ctem)
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (residualize-thunk) ; visit-revisit
+                  (build-revisit-only (residualize-thunk)))
+              (if (or (memq 'L ctem) (memq 'V ctem))
+                  (build-visit-only (residualize-thunk))
+                  (chi-void)))))))
+
+(define chi-frobs
+  (lambda (frob* r mr m?)
+    (map (lambda (x) (chi (frob-e x) r mr empty-wrap m?)) frob*)))
+
+(define chi-meta-frob
+  (lambda (x mr)
+    (chi (frob-e x) mr mr empty-wrap #t)))
+
+(define chi-sequence
+  (lambda (body r mr w ae m?)
+    (build-sequence ae
+      (let dobody ((body body))
+        (if (null? body)
+            '()
+            (let ((first (chi (car body) r mr w m?)))
+              (cons first (dobody (cdr body)))))))))
+
+(define chi
+  (lambda (e r mr w m?)
+    (let-values (((type value e w ae) (syntax-type e r w no-source #f)))
+      (chi-expr type value e r mr w ae m?))))
+
+(define chi-expr
+  (lambda (type value e r mr w ae m?)
+    (case type
+      ((lexical)
+       (build-lexical-reference 'value ae value))
+      ;;; AZIZ
+      ((core-primitive)
+       (build-primref ae value))
+      ((core) (value e r mr w ae m?))
+      ((lexical-call)
+       (chi-application
+         (build-lexical-reference 'fun
+           (let ((x (car e)))
+             (if (syntax-object? x) (syntax-object-expression x) x))
+           value)
+         e r mr w ae m?))
+      ((constant) (build-data ae (strip (source-wrap e w ae) empty-wrap)))
+      ((global) (build-global-reference ae value))
+      ((meta-variable)
+       (if m?
+           (build-global-reference ae value)
+           (displaced-lexical-error (source-wrap e w ae))))
+      ((call) (chi-application (chi (car e) r mr w m?) e r mr w ae m?))
+      ((begin-form) (chi-sequence (parse-begin e w ae #f) r mr w ae m?))
+      ((local-syntax-form)
+       (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+         (chi-sequence forms r mr w ae m?)))
+      ((eval-when-form)
+       (let-values (((when-list forms) (parse-eval-when e w ae)))
+         (if (memq 'eval when-list) ; mode set is implicitly (E)
+             (chi-sequence forms r mr w ae m?)
+             (chi-void))))
+      ((meta-form)
+       (syntax-error (source-wrap e w ae) "invalid context for meta definition"))
+      ((define-form)
+       (parse-define e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((define-syntax-form)
+       (parse-define-syntax e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      (($module-form)
+       (let-values (((orig id exports forms) (parse-module e w ae w)))
+         (syntax-error orig "invalid context for definition")))
+      (($import-form)
+       (let-values (((orig only? mid) (parse-import e w ae)))
+         (syntax-error orig "invalid context for definition")))
+      ((alias-form)
+       (parse-alias e w ae)
+       (syntax-error (source-wrap e w ae) "invalid context for definition"))
+      ((syntax)
+       (syntax-error (source-wrap e w ae)
+         "reference to pattern variable outside syntax form"))
+      ((displaced-lexical) (displaced-lexical-error (source-wrap e w ae)))
+      (else (syntax-error (source-wrap e w ae))))))
+
+(define chi-application
+  (lambda (x e r mr w ae m?)
+    (syntax-case e ()
+      ((e0 e1 ...)
+       (build-application ae x
+         (map (lambda (e) (chi e r mr w m?)) (syntax (e1 ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-set!
+  (lambda (e r w ae rib)
+    (syntax-case e ()
+      ((_ id val)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             ((macro!)
+              (let ((id (wrap (syntax id) w)) (val (wrap (syntax val) w)))
+                (syntax-type (chi-macro (binding-value b)
+                               `(,(syntax set!) ,id ,val)
+                               r empty-wrap #f rib) r empty-wrap #f rib)))
+             (else
+              (values 'core
+                (lambda (e r mr w ae m?)
+                 ; repeat lookup in case we were first expression (init) in
+                 ; module or lambda body.  we repeat id-var-name as well,
+                 ; although this is only necessary if we allow inits to
+                 ; preced definitions
+                  (let ((val (chi (syntax val) r mr w m?))
+                        (n (id-var-name (syntax id) w)))
+                    (let ((b (lookup n r)))
+                      (case (binding-type b)
+                        ((lexical) (build-lexical-assignment ae (binding-value b) val))
+                        ((global)
+                         (let ((sym (binding-value b)))
+                           (when (read-only-binding? n)
+                             (syntax-error (source-wrap e w ae)
+                               "invalid assignment to read-only variable"))
+                           (build-global-assignment ae sym val)))
+                        ((meta-variable)
+                         (if m?
+                             (build-global-assignment ae (binding-value b) val)
+                             (displaced-lexical-error (wrap (syntax id) w))))
+                        ((displaced-lexical)
+                         (displaced-lexical-error (wrap (syntax id) w)))
+                        (else (syntax-error (source-wrap e w ae)))))))
+                e w ae))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+
+
+(define chi-macro
+  (lambda (p e r w ae rib)
+    (define rebuild-macro-output
+      (lambda (x m)
+        (cond ((pair? x)
+               (cons (rebuild-macro-output (car x) m)
+                     (rebuild-macro-output (cdr x) m)))
+              ((syntax-object? x)
+               (let ((w (syntax-object-wrap x)))
+                 (let ((ms (wrap-marks w)) (s (wrap-subst w)))
+                   (make-syntax-object (syntax-object-expression x)
+                     (if (and (pair? ms) (eq? (car ms) the-anti-mark))
+                         (make-wrap (cdr ms) (cdr s))
+                         (make-wrap (cons m ms)
+                           (if rib
+                               (cons rib (cons 'shift s))
+                               (cons 'shift s))))))))
+              ((vector? x)
+               (let* ((n (vector-length x)) (v (make-vector n)))
+                 (do ((i 0 (fx+ i 1)))
+                     ((fx= i n) v)
+                     (vector-set! v i
+                       (rebuild-macro-output (vector-ref x i) m)))))
+              ((symbol? x)
+               (syntax-error (source-wrap e w ae)
+                 "encountered raw symbol "
+                (symbol->string x)
+                 " in output of macro"))
+              (else x))))
+    (rebuild-macro-output
+      (let ((out (p (source-wrap e (anti-mark w) ae))))
+        (if (procedure? out)
+            (out (lambda (id)
+                   (unless (identifier? id)
+                     (syntax-error id
+                       "environment argument is not an identifier"))
+                   (lookup (id-var-name id empty-wrap) r)))
+            out))
+      (new-mark))))
+
+(define chi-body
+  (lambda (body outer-form r mr w m?)
+    (let* ((ribcage (make-empty-ribcage))
+           (w (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))
+           (body (map (lambda (x) (make-frob (wrap x w) #f)) body)))
+      (let-values (((r mr exprs ids vars vals inits)
+                    (chi-internal ribcage outer-form body r mr m?)))
+        (when (null? exprs) (syntax-error outer-form "no expressions in body"))
+        (build-body no-source
+          (reverse vars) (chi-frobs (reverse vals) r mr m?)
+          (build-sequence no-source
+            (chi-frobs (append inits exprs) r mr m?)))))))
+
+(define chi-internal
+  ;; In processing the forms of the body, we create a new, empty wrap.
+  ;; This wrap is augmented (destructively) each time we discover that
+  ;; the next form is a definition.  This is done:
+  ;;
+  ;;   (1) to allow the first nondefinition form to be a call to
+  ;;       one of the defined ids even if the id previously denoted a
+  ;;       definition keyword or keyword for a macro expanding into a
+  ;;       definition;
+  ;;   (2) to prevent subsequent definition forms (but unfortunately
+  ;;       not earlier ones) and the first nondefinition form from
+  ;;       confusing one of the bound identifiers for an auxiliary
+  ;;       keyword; and
+  ;;   (3) so that we do not need to restart the expansion of the
+  ;;       first nondefinition form, which is problematic anyway
+  ;;       since it might be the first element of a begin that we
+  ;;       have just spliced into the body (meaning if we restarted,
+  ;;       we'd really need to restart with the begin or the macro
+  ;;       call that expanded into the begin, and we'd have to give
+  ;;       up allowing (begin <defn>+ <expr>+), which is itself
+  ;;       problematic since we don't know if a begin contains only
+  ;;       definitions until we've expanded it).
+  ;;
+  ;; Subforms of a begin, let-syntax, or letrec-syntax are spliced
+  ;; into the body.
+  ;;
+  ;; outer-form is fully wrapped w/source
+  (lambda (ribcage source-exp body r mr m?)
+    (define return
+      (lambda (r mr exprs ids vars vals inits)
+        (check-defined-ids source-exp ids)
+        (values r mr exprs ids vars vals inits)))
+    (let parse ((body body) (r r) (mr mr) (ids '()) (vars '()) (vals '()) (inits '()) (meta-seen? #f))
+      (if (null? body)
+          (return r mr body ids vars vals inits)
+          (let* ((fr (car body)) (e (frob-e fr)) (meta? (frob-meta? fr)))
+            (let-values (((type value e w ae) (syntax-type e r empty-wrap no-source ribcage)))
+              (case type
+                ((define-form)
+                 (let-values (((id rhs w) (parse-define e w ae)))
+                   (let ((id (wrap id w)) (label (gen-label)))
+                     (cond
+                       (meta?
+                        (let ((sym (generate-id (id-sym-name id))))
+                          (extend-ribcage! ribcage id label)
+                         ; add meta bindings only to meta environment
+                         ; so visible only to next higher level and beyond
+                          (let ((mr (extend-env label (make-binding 'meta-variable sym) mr)))
+                            (define-top-level-value-hook sym
+                              (top-level-eval-hook (chi rhs mr mr w #t)))
+                            (parse (cdr body) r mr (cons id ids) vars vals inits #f))))
+                       (else
+                        (let ((var (gen-var id)))
+                          (extend-ribcage! ribcage id label)
+                         ; add lexical bindings only to run-time environment
+                          (parse (cdr body)
+                            (extend-env label (make-binding 'lexical var) r)
+                            mr
+                            (cons id ids)
+                            (cons var vars)
+                            (cons (make-frob (wrap rhs w) meta?) vals)
+                            inits
+                            #f)))))))
+                ((define-syntax-form)
+                 (let-values (((id rhs w) (parse-define-syntax e w ae)))
+                   (let ((id (wrap id w))
+                         (label (gen-label))
+                         (exp (chi rhs mr mr w #t)))
+                     (extend-ribcage! ribcage id label)
+                     (let ((b (defer-or-eval-transformer local-eval-hook exp)))
+                       (parse (cdr body)
+                         (extend-env label b r) (extend-env label b mr)
+                         (cons id ids) vars vals inits #f)))))
+                (($module-form)
+                 (let* ((*ribcage (make-empty-ribcage))
+                        (*w (make-wrap (wrap-marks w) (cons *ribcage (wrap-subst w)))))
+                   (let-values (((orig id exports forms) (parse-module e w ae *w)))
+                     (let-values (((r mr *body *ids *vars *vals *inits)
+                                   (chi-internal *ribcage orig
+                                     (map (lambda (d) (make-frob d meta?)) forms)
+                                     r mr m?)))
+                      ; valid bound ids checked already by chi-internal
+                       (check-module-exports source-exp (flatten-exports exports) *ids)
+                       (let ((iface (make-resolved-interface id exports #f))
+                             (vars (append *vars vars))
+                             (vals (append *vals vals))
+                             (inits (append inits *inits *body))
+                             (label (gen-label)))
+                         (extend-ribcage! ribcage id label)
+                         (let ((b (make-binding '$module iface)))
+                           (parse (cdr body)
+                             (extend-env label b r) (extend-env label b mr)
+                             (cons id ids) vars vals inits #f)))))))
+               (($import-form)
+                (let-values (((orig only? mid) (parse-import e w ae)))
+                  (let ((mlabel (id-var-name mid empty-wrap)))
+                    (let ((binding (lookup mlabel r)))
+                      (case (binding-type binding)
+                        (($module)
+                         (let* ((iface (binding-value binding))
+                                (import-iface (make-import-interface iface (import-mark-delta mid iface))))
+                           (when only? (extend-ribcage-barrier! ribcage mid))
+                           (do-import! import-iface ribcage)
+                           (parse (cdr body) r mr (cons import-iface ids) vars vals inits #f)))
+                        ((displaced-lexical) (displaced-lexical-error mid))
+                        (else (syntax-error mid "unknown module")))))))
+                ((alias-form)
+                 (let-values (((new-id old-id) (parse-alias e w ae)))
+                   (let ((new-id (wrap new-id w)))
+                     (extend-ribcage! ribcage new-id (id-var-name-loc old-id w))
+                     (parse (cdr body) r mr
+                       (cons new-id ids)
+                       vars
+                       vals
+                       inits
+                       #f))))
+                ((begin-form)
+                 (parse (let f ((forms (parse-begin e w ae #t)))
+                          (if (null? forms)
+                              (cdr body)
+                              (cons (make-frob (wrap (car forms) w) meta?)
+                                    (f (cdr forms)))))
+                   r mr ids vars vals inits #f))
+                ((eval-when-form)
+                 (let-values (((when-list forms) (parse-eval-when e w ae)))
+                   (parse (if (memq 'eval when-list) ; mode set is implicitly (E)
+                              (let f ((forms forms))
+                                (if (null? forms)
+                                    (cdr body)
+                                    (cons (make-frob (wrap (car forms) w) meta?)
+                                          (f (cdr forms)))))
+                              (cdr body))
+                     r mr ids vars vals inits #f)))
+                ((meta-form)
+                 (parse (cons (make-frob (wrap (parse-meta e w ae) w) #t)
+                              (cdr body))
+                   r mr ids vars vals inits #t))
+                ((local-syntax-form)
+                 (let-values (((forms r mr w ae) (chi-local-syntax value e r mr w ae)))
+                   (parse (let f ((forms forms))
+                            (if (null? forms)
+                                (cdr body)
+                                (cons (make-frob (wrap (car forms) w) meta?)
+                                      (f (cdr forms)))))
+                     r mr ids vars vals inits #f)))
+                (else ; found a non-definition
+                 (when meta-seen? (syntax-error (source-wrap e w ae) "invalid meta definition"))
+                 (let f ((body (cons (make-frob (source-wrap e w ae) meta?) (cdr body))))
+                   (if (or (null? body) (not (frob-meta? (car body))))
+                       (return r mr body ids vars vals inits)
+                       (begin
+                        ; expand meta inits for effect only
+                         (top-level-eval-hook (chi-meta-frob (car body) mr))
+                         (f (cdr body)))))))))))))
+
+(define import-mark-delta
+ ; returns list of marks layered on top of module id beyond those
+ ; cached in the interface
+  (lambda (mid iface)
+    (diff-marks (id-marks mid) (interface-marks iface))))
+
+(define lookup-import-label
+  (lambda (id)
+    (let ((label (id-var-name-loc id empty-wrap)))
+      (unless label
+        (syntax-error id "exported identifier not visible"))
+      label)))
+  
+(define do-import!
+  (lambda (import-iface ribcage)
+    (let ((ie (interface-exports (import-interface-interface import-iface))))
+      (if (fx<= (vector-length ie) 20)
+          (let ((new-marks (import-interface-new-marks import-iface)))
+            (vfor-each
+              (lambda (id)
+                (import-extend-ribcage! ribcage new-marks id
+                  (lookup-import-label id)))
+              ie))
+          (extend-ribcage-subst! ribcage import-iface)))))
+
+(define parse-module
+  (lambda (e w ae *w)
+    (define listify
+      (lambda (exports)
+        (if (null? exports)
+            '()
+            (cons (syntax-case (car exports) ()
+                    ((ex ...) (listify (syntax (ex ...))))
+                    (x (if (id? (syntax x))
+                           (wrap (syntax x) *w)
+                           (syntax-error (source-wrap e w ae)
+                             "invalid exports list in"))))
+                  (listify (cdr exports))))))
+    (syntax-case e ()
+      ((_ orig mid (ex ...) form ...)
+       (id? (syntax mid))
+      ; id receives old wrap so it won't be confused with id of same name
+      ; defined within the module
+       (values (syntax orig) (wrap (syntax mid) w) (listify (syntax (ex ...))) (map (lambda (x) (wrap x *w)) (syntax (form ...)))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-import
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ orig #t mid)
+       (id? (syntax mid))
+       (values (syntax orig) #t (wrap (syntax mid) w)))
+      ((_ orig #f mid)
+       (id? (syntax mid))
+       (values (syntax orig) #f (wrap (syntax mid) w)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      ((_ (name . args) e1 e2 ...)
+       (and (id? (syntax name))
+            (valid-bound-ids? (lambda-var-list (syntax args))))
+       (values (wrap (syntax name) w)
+               (cons (syntax lambda) (wrap (syntax (args e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name)
+       (id? (syntax name))
+       (values (wrap (syntax name) w) (syntax (void)) empty-wrap))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-define-syntax
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (name id) e1 e2 ...)
+       (and (id? (syntax name)) (id? (syntax id)))
+       (values (wrap (syntax name) w)
+               `(,(syntax lambda) ,(wrap (syntax (id)) w)
+                   ,@(wrap (syntax (e1 e2 ...)) w))
+               empty-wrap))
+      ((_ name val)
+       (id? (syntax name))
+       (values (syntax name) (syntax val) w))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-meta
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ . form) (syntax form))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-eval-when
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ (x ...) e1 e2 ...)
+       (values (chi-when-list (syntax (x ...)) w) (syntax (e1 e2 ...))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-alias
+  (lambda (e w ae)
+    (syntax-case e ()
+      ((_ new-id old-id)
+       (and (id? (syntax new-id)) (id? (syntax old-id)))
+       (values (syntax new-id) (syntax old-id)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define parse-begin
+  (lambda (e w ae empty-okay?)
+    (syntax-case e ()
+      ((_) empty-okay? '())
+      ((_ e1 e2 ...) (syntax (e1 e2 ...)))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-lambda-clause
+  (lambda (e c r mr w m?)
+    (syntax-case c ()
+      (((id ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (values
+                 new-vars
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap ids labels w)
+                           m?))))))
+      ((ids e1 e2 ...)
+       (let ((old-ids (lambda-var-list (syntax ids))))
+         (if (not (valid-bound-ids? old-ids))
+             (syntax-error e "invalid parameter list in")
+             (let ((labels (gen-labels old-ids))
+                   (new-vars (map gen-var old-ids)))
+               (values
+                 (let f ((ls1 (cdr new-vars)) (ls2 (car new-vars)))
+                   (if (null? ls1)
+                       ls2
+                       (f (cdr ls1) (cons (car ls1) ls2))))
+                 (chi-body (syntax (e1 e2 ...))
+                           e
+                           (extend-var-env* labels new-vars r)
+                           mr
+                           (make-binding-wrap old-ids labels w)
+                           m?))))))
+      (_ (syntax-error e)))))
+
+(define chi-local-syntax
+  (lambda (rec? e r mr w ae)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae)
+               "keyword")
+             (let ((labels (gen-labels ids)))
+               (let ((new-w (make-binding-wrap ids labels w)))
+                 (let ((b* (let ((w (if rec? new-w w)))
+                             (map (lambda (x)
+                                    (defer-or-eval-transformer
+                                      local-eval-hook
+                                      (chi x mr mr w #t)))
+                                  (syntax (val ...))))))
+                   (values
+                     (syntax (e1 e2 ...))
+                     (extend-env* labels b* r)
+                     (extend-env* labels b* mr)
+                     new-w
+                     ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(define chi-void
+  (lambda ()
+    (build-application no-source (build-primref no-source 'void) '())))
+
+(define ellipsis?
+  (lambda (x)
+    (and (nonsymbol-id? x)
+         (literal-id=? x (syntax (... ...))))))
+
+;;; data
+
+;;; strips all annotations from potentially circular reader output.
+
+(define strip-annotation
+  (lambda (x)
+    (cond
+      ((pair? x)
+       (cons (strip-annotation (car x))
+             (strip-annotation (cdr x))))
+      ((annotation? x) (annotation-stripped x))
+      (else x))))
+
+;;; strips syntax-objects down to top-wrap; if top-wrap is layered directly
+;;; on an annotation, strips the annotation as well.
+;;; since only the head of a list is annotated by the reader, not each pair
+;;; in the spine, we also check for pairs whose cars are annotated in case
+;;; we've been passed the cdr of an annotated list
+
+(define strip*
+  (lambda (x w fn)
+    (if (top-marked? w)
+        (fn x)
+        (let f ((x x))
+          (cond
+            ((syntax-object? x)
+             (strip* (syntax-object-expression x) (syntax-object-wrap x) fn))
+            ((pair? x)
+             (let ((a (f (car x))) (d (f (cdr x))))
+               (if (and (eq? a (car x)) (eq? d (cdr x)))
+                   x
+                   (cons a d))))
+            ((vector? x)
+             (let ((old (vector->list x)))
+                (let ((new (map f old)))
+                   (if (andmap eq? old new) x (list->vector new)))))
+            (else x))))))
+
+(define strip
+  (lambda (x w)
+    (strip* x w
+      (lambda (x)
+        (if (or (annotation? x) (and (pair? x) (annotation? (car x))))
+            (strip-annotation x)
+            x)))))
+
+;;; lexical variables
+
+(define gen-var
+  (lambda (id)
+    (let ((id (if (syntax-object? id) (syntax-object-expression id) id)))
+      (if (annotation? id)
+          (build-lexical-var id (annotation-expression id))
+          (build-lexical-var id id)))))
+
+(define lambda-var-list
+  (lambda (vars)
+    (let lvl ((vars vars) (ls '()) (w empty-wrap))
+       (cond
+         ((pair? vars) (lvl (cdr vars) (cons (wrap (car vars) w) ls) w))
+         ((id? vars) (cons (wrap vars w) ls))
+         ((null? vars) ls)
+         ((syntax-object? vars)
+          (lvl (syntax-object-expression vars)
+               ls
+               (join-wraps w (syntax-object-wrap vars))))
+         ((annotation? vars)
+          (lvl (annotation-expression vars) ls w))
+       ; include anything else to be caught by subsequent error
+       ; checking
+         (else (cons vars ls))))))
+
+
+; must precede global-extends
+
+(primitive-set! '$sc-put-cte
+  (lambda (id b top-token)
+     (define sc-put-module
+       (lambda (exports token new-marks)
+         (vfor-each
+           (lambda (id) (store-import-binding id token new-marks))
+           exports)))
+     (define (put-cte id binding token)
+       (let ((sym (if (symbol? id) id (id-var-name id empty-wrap))))
+        (store-import-binding id token '())
+         (put-global-definition-hook sym
+          ; global binding is assumed; if global pass #f to remove existing binding, if any
+           (if (and (eq? (binding-type binding) 'global)
+                    (eq? (binding-value binding) sym))
+               #f
+               binding))))
+     (let ((binding (make-transformer-binding b)))
+       (case (binding-type binding)
+         (($module)
+          (let ((iface (binding-value binding)))
+            (sc-put-module (interface-exports iface) (interface-token iface) '()))
+          (put-cte id binding top-token))
+         ((do-alias) (store-import-binding id top-token '()))
+         ((do-import)
+          ; fake binding: id is module id binding-value is token
+          (let ((token (binding-value b)))
+             (let ((b (lookup (id-var-name id empty-wrap) null-env)))
+               (case (binding-type b)
+                 (($module)
+                  (let* ((iface (binding-value b))
+                         (exports (interface-exports iface)))
+                    (unless (eq? (interface-token iface) token)
+                      (syntax-error id "import mismatch for module"))
+                    (sc-put-module (interface-exports iface) top-token
+                      (import-mark-delta id iface))))
+                 (else (syntax-error id "unknown module"))))))
+         (else (put-cte id binding top-token))))
+     ))
+
+
+;;; core transformers
+
+(global-extend 'local-syntax 'letrec-syntax #t)
+(global-extend 'local-syntax 'let-syntax #f)
+
+
+(global-extend 'core 'fluid-let-syntax
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((var val) ...) e1 e2 ...)
+       (valid-bound-ids? (syntax (var ...)))
+       (let ((names (map (lambda (x) (id-var-name x w)) (syntax (var ...)))))
+         (for-each
+           (lambda (id n)
+             (case (binding-type (lookup n r))
+               ((displaced-lexical) (displaced-lexical-error (wrap id w)))))
+           (syntax (var ...))
+           names)
+         (let ((b* (map (lambda (x)
+                          (defer-or-eval-transformer
+                            local-eval-hook
+                            (chi x mr mr w #t)))
+                        (syntax (val ...)))))
+           (chi-body
+             (syntax (e1 e2 ...))
+             (source-wrap e w ae)
+             (extend-env* names b* r)
+             (extend-env* names b* mr)
+             w
+             m?))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'quote
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ e) (build-data ae (strip (syntax e) w)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core '|#primitive|
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ name) (id? #'name)
+          (let ([name (strip (syntax name) w)])
+            (if (or (memq name (public-primitives))
+                    (memq name (system-primitives)))
+                (build-primref ae name)
+                (syntax-error (source-wrap e w ae)))))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+(global-extend 'core 'syntax
+  (let ()
+    (define gen-syntax
+      (lambda (src e r maps ellipsis? vec?)
+        (if (id? e)
+            (let ((label (id-var-name e empty-wrap)))
+              (let ((b (lookup label r)))
+                (if (eq? (binding-type b) 'syntax)
+                    (let-values (((var maps)
+                                  (let ((var.lev (binding-value b)))
+                                    (gen-ref src (car var.lev) (cdr var.lev) maps))))
+                      (values `(ref ,var) maps))
+                    (if (ellipsis? e)
+                        (syntax-error src "misplaced ellipsis in syntax form")
+                        (values `(quote ,e) maps)))))
+            (syntax-case e ()
+              ((dots e)
+               (ellipsis? (syntax dots))
+               (if vec?
+                   (syntax-error src "misplaced ellipsis in syntax template")
+                   (gen-syntax src (syntax e) r maps (lambda (x) #f) #f)))
+              ((x dots . y)
+               ; this could be about a dozen lines of code, except that we
+               ; choose to handle (syntax (x ... ...)) forms
+               (ellipsis? (syntax dots))
+               (let f ((y (syntax y))
+                       (k (lambda (maps)
+                            (let-values (((x maps)
+                                          (gen-syntax src (syntax x) r
+                                            (cons '() maps) ellipsis? #f)))
+                              (if (null? (car maps))
+                                  (syntax-error src
+                                    "extra ellipsis in syntax form")
+                                  (values (gen-map x (car maps))
+                                          (cdr maps)))))))
+                 (syntax-case y ()
+                   ((dots . y)
+                    (ellipsis? (syntax dots))
+                    (f (syntax y)
+                       (lambda (maps)
+                         (let-values (((x maps) (k (cons '() maps))))
+                           (if (null? (car maps))
+                               (syntax-error src
+                                 "extra ellipsis in syntax form")
+                               (values (gen-mappend x (car maps))
+                                       (cdr maps)))))))
+                   (_ (let-values (((y maps) (gen-syntax src y r maps ellipsis? vec?)))
+                        (let-values (((x maps) (k maps)))
+                          (values (gen-append x y) maps)))))))
+              ((x . y)
+               (let-values (((xnew maps) (gen-syntax src (syntax x) r maps ellipsis? #f)))
+                 (let-values (((ynew maps) (gen-syntax src (syntax y) r maps ellipsis? vec?)))
+                   (values (gen-cons e (syntax x) (syntax y) xnew ynew)
+                           maps))))
+              (#(x1 x2 ...)
+               (let ((ls (syntax (x1 x2 ...))))
+                 (let-values (((lsnew maps) (gen-syntax src ls r maps ellipsis? #t)))
+                   (values (gen-vector e ls lsnew) maps))))
+              (_ (values `(quote ,e) maps))))))
+
+    (define gen-ref
+      (lambda (src var level maps)
+        (if (fx= level 0)
+            (values var maps)
+            (if (null? maps)
+                (syntax-error src "missing ellipsis in syntax form")
+                (let-values (((outer-var outer-maps) (gen-ref src var (fx- level 1) (cdr maps))))
+                  (let ((b (assq outer-var (car maps))))
+                    (if b
+                        (values (cdr b) maps)
+                        (let ((inner-var (gen-var 'tmp)))
+                          (values inner-var
+                                  (cons (cons (cons outer-var inner-var)
+                                              (car maps))
+                                        outer-maps))))))))))
+
+    (define gen-append
+      (lambda (x y)
+        (if (equal? y '(quote ()))
+            x
+            `(append ,x ,y))))
+
+    (define gen-mappend
+      (lambda (e map-env)
+        `(apply (primitive append) ,(gen-map e map-env))))
+
+    (define gen-map
+      (lambda (e map-env)
+        (let ((formals (map cdr map-env))
+              (actuals (map (lambda (x) `(ref ,(car x))) map-env)))
+          (cond
+            ((eq? (car e) 'ref)
+             ; identity map equivalence:
+             ; (map (lambda (x) x) y) == y
+             (car actuals))
+            ((andmap
+                (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) formals)))
+                (cdr e))
+             ; eta map equivalence:
+             ; (map (lambda (x ...) (f x ...)) y ...) == (map f y ...)
+             `(map (primitive ,(car e))
+                   ,@(map (let ((r (map cons formals actuals)))
+                            (lambda (x) (cdr (assq (cadr x) r))))
+                          (cdr e))))
+            (else `(map (case-lambda [,formals ,e]) ,@actuals))))))
+
+   ; 12/12/00: semantic change: we now return original syntax object (e)
+   ; if no pattern variables were found within, to avoid dropping
+   ; source annotations prematurely.  the "syntax returns lists" for
+   ; lists in its input guarantee counts only for substructure that
+   ; contains pattern variables
+    (define gen-cons
+      (lambda (e x y xnew ynew)
+        (case (car ynew)
+          ((quote)
+           (if (eq? (car xnew) 'quote)
+               (let ((xnew (cadr xnew)) (ynew (cadr ynew)))
+                 (if (and (eq? xnew x) (eq? ynew y))
+                     `',e
+                     `'(,xnew . ,ynew)))
+               (if (eq? (cadr ynew) '()) `(list ,xnew) `(cons ,xnew ,ynew))))
+          ((list) `(list ,xnew ,@(cdr ynew)))
+          (else `(cons ,xnew ,ynew)))))
+
+    (define gen-vector
+      (lambda (e ls lsnew)
+        (cond
+          ((eq? (car lsnew) 'quote)
+           (if (eq? (cadr lsnew) ls)
+               `',e
+               `(quote #(,@(cadr lsnew)))))
+          ((eq? (car lsnew) 'list) `(vector ,@(cdr lsnew)))
+          (else `(list->vector ,lsnew)))))
+
+
+    (define regen
+      (lambda (x)
+        (case (car x)
+          ((ref) (build-lexical-reference 'value no-source (cadr x)))
+          ((primitive) (build-primref no-source (cadr x)))
+          ((quote) (build-data no-source (cadr x)))
+          ((lambda) 
+           (build-lambda no-source (cadr x) (regen (caddr x))))
+          ((case-lambda)
+           (let ([d (cdr x)])
+             (build-case-lambda no-source
+              (map car d)
+              (map (lambda (x) (regen (cadr x))) d))))
+          ((map) (let ((ls (map regen (cdr x))))
+                   (build-application no-source
+                     (if (fx= (length ls) 2)
+                         (build-primref no-source 'map)
+                        ; really need to do our own checking here
+                         (build-primref no-source 2 'map)) ; require error check
+                     ls)))
+          (else (build-application no-source
+                  (build-primref no-source (car x))
+                  (map regen (cdr x)))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ x)
+           (let-values (((e maps) (gen-syntax e (syntax x) r '() ellipsis? #f)))
+             (regen e)))
+          (_ (syntax-error e)))))))
+
+
+(global-extend 'core 'lambda
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ . c)
+       (let-values (((vars body)
+                     (chi-lambda-clause 
+                       (source-wrap e w ae) 
+                       (syntax c) r mr w m?)))
+         (build-lambda ae vars body))))))
+
+;;; AZIZ
+(global-extend 'core 'case-lambda
+   (lambda (e r mr w ae m?)
+     (syntax-case e ()
+       [(_ c* ...)
+        (let-values ([(vars* body*)
+                      (let f ([c* #'(c* ...)])
+                        (syntax-case c* ()
+                          [() (values '() '())]
+                          [(c . c*) 
+                           (let-values ([(vars body)
+                                         (chi-lambda-clause
+                                           (source-wrap e w ae)
+                                           #'c r mr w m?)])
+                             (let-values ([(vars* body*) (f #'c*)])
+                               (values 
+                                 (cons vars vars*)
+                                 (cons body body*))))]))])
+           (build-case-lambda ae vars* body*))])))
+
+
+
+
+(global-extend 'core 'letrec
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ ((id val) ...) e1 e2 ...)
+       (let ((ids (syntax (id ...))))
+         (if (not (valid-bound-ids? ids))
+             (invalid-ids-error (map (lambda (x) (wrap x w)) ids)
+               (source-wrap e w ae) "bound variable")
+             (let ((labels (gen-labels ids))
+                   (new-vars (map gen-var ids)))
+               (let ((w (make-binding-wrap ids labels w))
+                    (r (extend-var-env* labels new-vars r)))
+                 (build-letrec ae
+                   new-vars
+                   (map (lambda (x) (chi x r mr w m?)) (syntax (val ...)))
+                   (chi-body (syntax (e1 e2 ...)) (source-wrap e w ae) r mr w m?)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'core 'if
+   (lambda (e r mr w ae m?)
+      (syntax-case e ()
+         ((_ test then)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi-void)))
+         ((_ test then else)
+          (build-conditional ae
+             (chi (syntax test) r mr w m?)
+             (chi (syntax then) r mr w m?)
+             (chi (syntax else) r mr w m?)))
+         (_ (syntax-error (source-wrap e w ae))))))
+
+;;; AZIZ
+(global-extend 'core 'foreign-call
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-foreign-call ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+(global-extend 'core '$apply
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-$apply ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+;;; AZIZ
+(global-extend 'core 'type-descriptor
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ id)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             (($rtd) 
+              (build-data ae (binding-value b)))
+             (else (syntax-error (source-wrap e w ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
+
+
+(global-extend 'set! 'set! '())
+
+(global-extend 'alias 'alias '())
+(global-extend 'begin 'begin '())
+
+(global-extend '$module-key '$module '())
+(global-extend '$import '$import '())
+
+(global-extend 'define 'define '())
+
+(global-extend 'define-syntax 'define-syntax '())
+
+(global-extend 'eval-when 'eval-when '())
+
+(global-extend 'meta 'meta '())
+
+(global-extend 'core 'syntax-case
+  (let ()
+    (define convert-pattern
+      ; accepts pattern & keys
+      ; returns syntax-dispatch pattern & ids
+      (lambda (pattern keys)
+        (define cvt*
+          (lambda (p* n ids)
+            (if (null? p*)
+                (values '() ids)
+                (let-values (((y ids) (cvt* (cdr p*) n ids)))
+                  (let-values (((x ids) (cvt (car p*) n ids)))
+                    (values (cons x y) ids))))))
+        (define cvt
+          (lambda (p n ids)
+            (if (id? p)
+                (if (bound-id-member? p keys)
+                    (values (vector 'free-id p) ids)
+                    (values 'any (cons (cons p n) ids)))
+                (syntax-case p ()
+                  ((x dots)
+                   (ellipsis? (syntax dots))
+                   (let-values (((p ids) (cvt (syntax x) (fx+ n 1) ids)))
+                     (values (if (eq? p 'any) 'each-any (vector 'each p))
+                             ids)))
+                  ((x dots y ... . z)
+                   (ellipsis? (syntax dots))
+                   (let-values (((z ids) (cvt (syntax z) n ids)))
+                     (let-values (((y ids) (cvt* (syntax (y ...)) n ids)))
+                       (let-values (((x ids) (cvt (syntax x) (fx+ n 1) ids)))
+                         (values `#(each+ ,x ,(reverse y) ,z) ids)))))
+                  ((x . y)
+                   (let-values (((y ids) (cvt (syntax y) n ids)))
+                     (let-values (((x ids) (cvt (syntax x) n ids)))
+                       (values (cons x y) ids))))
+                  (() (values '() ids))
+                  (#(x ...)
+                   (let-values (((p ids) (cvt (syntax (x ...)) n ids)))
+                     (values (vector 'vector p) ids)))
+                  (x (values (vector 'atom (strip p empty-wrap)) ids))))))
+        (cvt pattern 0 '())))
+
+    (define build-dispatch-call
+      (lambda (pvars exp y r mr m?)
+        (let ((ids (map car pvars)) (levels (map cdr pvars)))
+          (let ((labels (gen-labels ids)) (new-vars (map gen-var ids)))
+            (build-application no-source
+              (build-primref no-source 'apply)
+              (list (build-lambda no-source new-vars
+                      (chi exp
+                         (extend-env*
+                             labels
+                             (map (lambda (var level)
+                                    (make-binding 'syntax `(,var . ,level)))
+                                  new-vars
+                                  (map cdr pvars))
+                             r)
+                         mr
+                         (make-binding-wrap ids labels empty-wrap)
+                         m?))
+                    y))))))
+
+    (define gen-clause
+      (lambda (x keys clauses r mr m? pat fender exp)
+        (let-values (((p pvars) (convert-pattern pat keys)))
+          (cond
+            ((not (distinct-bound-ids? (map car pvars)))
+             (invalid-ids-error (map car pvars) pat "pattern variable"))
+            ((not (andmap (lambda (x) (not (ellipsis? (car x)))) pvars))
+             (syntax-error pat
+               "misplaced ellipsis in syntax-case pattern"))
+            (else
+             (let ((y (gen-var 'tmp)))
+               ; fat finger binding and references to temp variable y
+               (build-application no-source
+                 (build-lambda no-source (list y)
+                   (let-syntax ((y (identifier-syntax
+                                     (build-lexical-reference 'value no-source y))))
+                     (build-conditional no-source
+                       (syntax-case fender ()
+                         (#t y)
+                         (_ (build-conditional no-source
+                              y
+                              (build-dispatch-call pvars fender y r mr m?)
+                              (build-data no-source #f))))
+                       (build-dispatch-call pvars exp y r mr m?)
+                       (gen-syntax-case x keys clauses r mr m?))))
+                 (list (if (eq? p 'any)
+                           (build-application no-source
+                             (build-primref no-source 'list)
+                             (list (build-lexical-reference no-source 'value x)))
+                           (build-application no-source
+                             (build-primref no-source '$syntax-dispatch)
+                             (list (build-lexical-reference no-source 'value x)
+                                   (build-data no-source p))))))))))))
+
+    (define gen-syntax-case
+      (lambda (x keys clauses r mr m?)
+        (if (null? clauses)
+            (build-application no-source
+              (build-primref no-source 'syntax-error)
+              (list (build-lexical-reference 'value no-source x)))
+            (syntax-case (car clauses) ()
+              ((pat exp)
+               (if (and (id? (syntax pat))
+                        (not (bound-id-member? (syntax pat) keys))
+                        (not (ellipsis? (syntax pat))))
+                   (let ((label (gen-label))
+                         (var (gen-var (syntax pat))))
+                     (build-application no-source
+                       (build-lambda no-source (list var)
+                         (chi (syntax exp)
+                              (extend-env label (make-binding 'syntax `(,var . 0)) r)
+                              mr
+                              (make-binding-wrap (syntax (pat))
+                                (list label) empty-wrap)
+                              m?))
+                       (list (build-lexical-reference 'value no-source x))))
+                   (gen-clause x keys (cdr clauses) r mr m?
+                     (syntax pat) #t (syntax exp))))
+              ((pat fender exp)
+               (gen-clause x keys (cdr clauses) r mr m?
+                 (syntax pat) (syntax fender) (syntax exp)))
+              (_ (syntax-error (car clauses) "invalid syntax-case clause"))))))
+
+    (lambda (e r mr w ae m?)
+      (let ((e (source-wrap e w ae)))
+        (syntax-case e ()
+          ((_ val (key ...) m ...)
+           (if (andmap (lambda (x) (and (id? x) (not (ellipsis? x))))
+                       (syntax (key ...)))
+               (let ((x (gen-var 'tmp)))
+                 ; fat finger binding and references to temp variable x
+                 (build-application ae
+                   (build-lambda no-source (list x)
+                     (gen-syntax-case x
+                       (syntax (key ...)) (syntax (m ...))
+                       r mr m?))
+                   (list (chi (syntax val) r mr empty-wrap m?))))
+               (syntax-error e "invalid literals list in"))))))))
+
+(put-cte-hook 'module
+  (lambda (x)
+    (define proper-export?
+      (lambda (e)
+        (syntax-case e ()
+          ((id e ...)
+           (and (identifier? (syntax id))
+                (andmap proper-export? (syntax (e ...)))))
+          (id (identifier? (syntax id))))))
+    (with-syntax ((orig x))
+      (syntax-case x ()
+        ((_ (e ...) d ...)
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               (begin 
+                 ($module orig anon (e ...) d ...)
+                 ($import orig #f anon)))
+             (syntax-error x "invalid exports list in")))
+        ((_ m (e ...) d ...)
+         (identifier? (syntax m))
+         (if (andmap proper-export? (syntax (e ...)))
+             (syntax 
+               ($module orig m (e ...) d ...))
+             (syntax-error x "invalid exports list in")))))))
+
+(let ()
+  (define $module-exports
+    (lambda (m r)
+      (let ((b (r m)))
+        (case (binding-type b)
+          (($module)
+           (let* ((interface (binding-value b))
+                  (new-marks (import-mark-delta m interface)))
+             (vmap (lambda (x)
+                     (let ((id (if (pair? x) (car x) x)))
+                       (make-syntax-object
+                         (syntax-object->datum id)
+                         (let ((marks (join-marks new-marks (wrap-marks (syntax-object-wrap id))))) 
+                           (make-wrap marks
+                                     ; the anti mark should always be present at the head
+                                     ; of new-marks, but we paranoically check anyway
+                                      (if (eq? (car marks) the-anti-mark)
+                                          (cons 'shift (wrap-subst top-wrap))
+                                          (wrap-subst top-wrap)))))))
+                   (interface-exports interface))))
+          ((displaced-lexical) (displaced-lexical-error m))
+          (else (syntax-error m "unknown module"))))))
+  (define $import-help
+    (lambda (orig import-only?)
+      (lambda (r)
+        (define difference
+          (lambda (ls1 ls2)
+            (if (null? ls1)
+                ls1
+                (if (bound-id-member? (car ls1) ls2)
+                    (difference (cdr ls1) ls2)
+                    (cons (car ls1) (difference (cdr ls1) ls2))))))
+        (define prefix-add
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (datum->syntax-object id
+                  (string->symbol
+                    (string-append prefix
+                      (symbol->string (syntax-object->datum id)))))))))
+        (define prefix-drop
+          (lambda (prefix-id)
+            (let ((prefix (symbol->string (syntax-object->datum prefix-id))))
+              (lambda (id)
+                (let ((s (symbol->string (syntax-object->datum id))))
+                  (let ((np (string-length prefix)) (ns (string-length s)))
+                    (unless (and (fx>= ns np) (string=? (substring s 0 np) prefix))
+                      (syntax-error id (string-append "missing expected prefix " prefix)))
+                    (datum->syntax-object id
+                      (string->symbol (substring s np ns)))))))))
+        (define gen-mid
+          (lambda (mid)
+           ; introduced module ids must have same marks as original
+           ; for import-only, since the barrier carries the marks of
+           ; the module id
+            (datum->syntax-object mid (gensym-hook))))
+        (define (modspec m exports?)
+          (with-syntax ((orig orig) (import-only? import-only?))
+            (syntax-case m (only-for-syntax also-for-syntax
+                            only except
+                            add-prefix drop-prefix rename alias)
+              ((only m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #f)))
+                 (with-syntax ((d d) (tmid (gen-mid mid)))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((except m id ...)
+               (andmap identifier? (syntax (id ...)))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((id ...) (difference exports (syntax (id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid (id ...) d) ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((add-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-add (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((drop-prefix m prefix-id)
+               (identifier? (syntax prefix-id))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((old-id ...) exports)
+                               ((tmp ...) (generate-temporaries exports))
+                               ((id ...) (map (prefix-drop (syntax prefix-id)) exports)))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((id tmp) ...)
+                                            ($module orig tmid ((tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (id ...)))))))
+              ((rename m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((tmp ...) (generate-temporaries (syntax (old-id ...))))
+                               ((other-id ...) (difference exports (syntax (old-id ...)))))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id tmp) ... other-id ...)
+                                            ($module orig tmid (other-id ... (tmp old-id) ...) d (alias tmp old-id) ...)
+                                            ($import orig import-only? tmid)
+                                            (alias new-id tmp) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+              ((alias m (new-id old-id) ...)
+               (and (andmap identifier? (syntax (new-id ...)))
+                    (andmap identifier? (syntax (old-id ...))))
+               (let-values (((mid d exports) (modspec (syntax m) #t)))
+                 (with-syntax ((d d)
+                               (tmid (gen-mid mid))
+                               ((other-id ...) exports))
+                   (values mid
+                           (syntax (begin ($module orig tmid ((new-id old-id) ... other-id ...) d (alias new-id old-id) ...)
+                                          ($import orig import-only? tmid)))
+                           (and exports? (syntax (new-id ... other-id ...)))))))
+             ; base cases
+              (mid
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+              ((mid)
+               (identifier? (syntax mid))
+               (values (syntax mid)
+                       (syntax ($import orig import-only? mid))
+                       (and exports? ($module-exports (syntax mid) r))))
+            (_ (syntax-error m "invalid module specifier")))))
+        (define modspec*
+          (lambda (m)
+            (let-values (((mid d exports) (modspec m #f))) d)))
+        (syntax-case orig ()
+          ((_ m ...)
+           (with-syntax (((d ...) (map modspec* (syntax (m ...)))))
+             (syntax (begin d ...))))))))
+
+  (put-cte-hook 'import
+    (lambda (orig)
+      ($import-help orig #f)))
+  
+  (put-cte-hook 'import-only
+    (lambda (orig)
+      ($import-help orig #t)))
+)
+
+;;; To support eval-when, we maintain two mode sets:
+;;;
+;;; ctem (compile-time-expression mode)
+;;;   determines whether/when to evaluate compile-time expressions such
+;;;   as macro definitions, module definitions, and compile-time
+;;;   registration of variable definitions
+;;;
+;;; rtem (run-time-expression mode)
+;;;   determines whether/when to evaluate run-time expressions such
+;;;   as the actual assignment performed by a variable definition or
+;;;   arbitrary top-level expressions
+
+;;; Possible modes in the mode set are:
+;;;
+;;; L (load): evaluate at load time.  implies V for compile-time
+;;;     expressions and R for run-time expressions.
+;;;
+;;; C (compile): evaluate at compile (file) time
+;;;
+;;; E (eval): evaluate at evaluation (compile or interpret) time
+;;;
+;;; V (visit): evaluate at visit time
+;;;
+;;; R (revisit): evaluate at revisit time
+
+;;; The mode set for the body of an eval-when is determined by
+;;; translating each mode in the old mode set based on the situations
+;;; present in the eval-when form and combining these into a set,
+;;; using the following table.  See also update-mode-set.
+
+;;;      load  compile  visit  revisit  eval
+;;;
+;;; L     L      C        V       R      -
+;;;
+;;; C     -      -        -       -      C
+;;;
+;;; V     V      C        V       -      -
+;;;
+;;; R     R      C        -       R      -
+;;;
+;;; E     -      -        -       -      E
+
+;;; When we complete the expansion of a compile or run-time expression,
+;;; the current ctem or rtem determines how the expression will be
+;;; treated.  See ct-eval/residualize and rt-eval/residualize.
+
+;;; Initial mode sets
+;;;
+;;; when compiling a file:
+;;;
+;;;     initial ctem: (L C)
+;;;
+;;;     initial rtem: (L)
+;;;
+;;; when not compiling a file:
+;;;
+;;;     initial ctem: (E)
+;;;
+;;;     initial rtem: (E)
+;;;
+;;;
+;;; This means that top-level syntactic definitions are evaluated
+;;; immediately after they are expanded, and the expanded definitions
+;;; are also residualized into the object file if we are compiling
+;;; a file.
+
+
+
+;;; AZIZ
+;;; (set! sc-expand
+;;;   (let ((ctem '(E)) (rtem '(E)))
+;;;     (lambda (x)
+;;;       (let ((env (interaction-environment)))
+;;;         (if (and (pair? x) (equal? (car x) noexpand))
+;;;             (cadr x)
+;;;             (chi-top* x null-env
+;;;               (env-wrap env)
+;;;               ctem rtem #f
+;;;               (env-top-ribcage env)))))))
+;;; 
+
+(primitive-set! 'expand-mode
+  (make-parameter
+    'eval
+    (lambda (x)
+      (unless (memq x '(eval compile bootstrap))
+        (error 'expand-mode "~s is not a valid mode" x))
+      x)))
+
+(primitive-set! 'sc-expand
+  (let ()
+    (define get-modes
+      (lambda ()
+        (case (expand-mode)
+          [(eval)      (values '(E)   '(E))]
+          [(compile)   (values '(L C) '(L))]
+          [(bootstrap) (values '(L)   '(L))])))
+    (lambda (x)
+      (let ((env (interaction-environment)))
+        (let-values ([(ctem rtem) (get-modes)])
+          (if (and (pair? x) (equal? (car x) noexpand))
+              (cadr x)
+              (chi-top* x null-env
+                (env-wrap env)
+                ctem rtem #f
+                (env-top-ribcage env))))))))
+
+(primitive-set! 'current-expand
+  (make-parameter
+    sc-expand
+    (lambda (x)
+      (unless (procedure? x)
+        (error 'current-expand "~s is not a procedure" x))
+      x)))
+
+(primitive-set! 'expand
+  (lambda (x)
+    ((current-expand) x)))
+
+(primitive-set! '$make-environment
+  (lambda (token mutable?)
+    (let ((top-ribcage (make-top-ribcage token mutable?)))
+      (make-env
+        top-ribcage
+        (make-wrap
+          (wrap-marks top-wrap)
+          (cons top-ribcage (wrap-subst top-wrap)))))))
+
+(primitive-set! 'environment?
+  (lambda (x)
+    (env? x)))
+
+
+;;; AZIZ
+;;; (primitive-set! 'interaction-environment
+;;;   (let ((e ($make-environment '*top* #t)))
+;;;     (lambda () e)))
+
+(primitive-set! 'interaction-environment
+  (make-parameter
+    ($make-environment '*top* #t)
+    (lambda (x)
+      (if (environment? x)
+          x
+          (error 'interaction-environment "~s is not an environment" x)))))
+
+
+(primitive-set! 'identifier?
+  (lambda (x)
+    (nonsymbol-id? x)))
+
+(primitive-set! 'datum->syntax-object
+  (lambda (id datum)
+    (arg-check nonsymbol-id? id 'datum->syntax-object)
+    (make-syntax-object
+      datum
+      (syntax-object-wrap id))))
+
+(primitive-set! 'syntax->list
+  (lambda (orig-ls)
+    (let f ((ls orig-ls))
+      (syntax-case ls ()
+        (() '())
+        ((x . r) (cons #'x (f #'r)))
+        (_ (error 'syntax->list "invalid argument ~s" orig-ls))))))
+
+(primitive-set! 'syntax->vector
+  (lambda (v)
+    (syntax-case v ()
+      (#(x ...) (apply vector (syntax->list #'(x ...))))
+      (_ (error 'syntax->vector "invalid argument ~s" v)))))
+
+(primitive-set! 'syntax-object->datum
+  ; accepts any object, since syntax objects may consist partially
+  ; or entirely of unwrapped, nonsymbolic data
+  (lambda (x)
+    (strip x empty-wrap)))
+
+(primitive-set! 'generate-temporaries
+  (lambda (ls)
+    (arg-check list? ls 'generate-temporaries)
+    (map (lambda (x) (wrap (gensym-hook) top-wrap)) ls)))
+
+(primitive-set! 'free-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'free-identifier=?)
+      (arg-check nonsymbol-id? y 'free-identifier=?)
+      (free-id=? x y)))
+
+(primitive-set! 'bound-identifier=?
+   (lambda (x y)
+      (arg-check nonsymbol-id? x 'bound-identifier=?)
+      (arg-check nonsymbol-id? y 'bound-identifier=?)
+      (bound-id=? x y)))
+
+(primitive-set! 'literal-identifier=?
+  (lambda (x y)
+    (arg-check nonsymbol-id? x 'literal-identifier=?)
+    (arg-check nonsymbol-id? y 'literal-identifier=?)
+    (literal-id=? x y)))
+
+(primitive-set! 'syntax-error
+  (lambda (object . messages)
+    (for-each (lambda (x) (arg-check string? x 'syntax-error)) messages)
+    (let ((message (if (null? messages)
+                       "invalid syntax"
+                       (apply string-append messages))))
+      (error-hook #f message (strip object empty-wrap)))))
+
+;;; syntax-dispatch expects an expression and a pattern.  If the expression
+;;; matches the pattern a list of the matching expressions for each
+;;; "any" is returned.  Otherwise, #f is returned.  (This use of #f will
+;;; not work on r4rs implementations that violate the ieee requirement
+;;; that #f and () be distinct.)
+
+;;; The expression is matched with the pattern as follows:
+
+;;; p in pattern:                        matches:
+;;;   ()                                 empty list
+;;;   any                                anything
+;;;   (p1 . p2)                          pair (list)
+;;;   #(free-id <key>)                   <key> with literal-identifier=?
+;;;   each-any                           any proper list
+;;;   #(each p)                          (p*)
+;;;   #(each+ p1 (p2_1 ...p2_n) p3)      (p1* (p2_n ... p2_1) . p3)
+;;;   #(vector p)                        (list->vector p)
+;;;   #(atom <object>)                   <object> with "equal?"
+
+;;; Vector cops out to pair under assumption that vectors are rare.  If
+;;; not, should convert to:
+;;;   #(vector p)                        #(p*)
+
+(let ()
+
+(define match-each
+  (lambda (e p w)
+    (cond
+      ((annotation? e)
+       (match-each (annotation-expression e) p w))
+      ((pair? e)
+       (let ((first (match (car e) p w '())))
+         (and first
+              (let ((rest (match-each (cdr e) p w)))
+                 (and rest (cons first rest))))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each (syntax-object-expression e)
+                   p
+                   (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-each+
+  (lambda (e x-pat y-pat z-pat w r)
+    (let f ((e e) (w w))
+      (cond
+        ((pair? e)
+         (let-values (((xr* y-pat r) (f (cdr e) w)))
+           (if r
+               (if (null? y-pat)
+                   (let ((xr (match (car e) x-pat w '())))
+                     (if xr
+                         (values (cons xr xr*) y-pat r)
+                         (values #f #f #f)))
+                   (values '() (cdr y-pat) (match (car e) (car y-pat) w r)))
+               (values #f #f #f))))
+        ((annotation? e) (f (annotation-expression e) w))
+        ((syntax-object? e) (f (syntax-object-expression e)
+                               (join-wraps w (syntax-object-wrap e))))
+        (else (values '() y-pat (match e z-pat w r)))))))
+
+(define match-each-any
+  (lambda (e w)
+    (cond
+      ((annotation? e)
+       (match-each-any (annotation-expression e) w))
+      ((pair? e)
+       (let ((l (match-each-any (cdr e) w)))
+         (and l (cons (wrap (car e) w) l))))
+      ((null? e) '())
+      ((syntax-object? e)
+       (match-each-any (syntax-object-expression e)
+                       (join-wraps w (syntax-object-wrap e))))
+      (else #f))))
+
+(define match-empty
+  (lambda (p r)
+    (cond
+      ((null? p) r)
+      ((eq? p 'any) (cons '() r))
+      ((pair? p) (match-empty (car p) (match-empty (cdr p) r)))
+      ((eq? p 'each-any) (cons '() r))
+      (else
+       (case (vector-ref p 0)
+         ((each) (match-empty (vector-ref p 1) r))
+         ((each+) (match-empty (vector-ref p 1)
+                    (match-empty (reverse (vector-ref p 2))
+                      (match-empty (vector-ref p 3) r))))
+         ((free-id atom) r)
+         ((vector) (match-empty (vector-ref p 1) r)))))))
+
+(define combine
+  (lambda (r* r)
+    (if (null? (car r*))
+        r
+        (cons (map car r*) (combine (map cdr r*) r)))))
+
+(define match*
+  (lambda (e p w r)
+    (cond
+      ((null? p) (and (null? e) r))
+      ((pair? p)
+       (and (pair? e) (match (car e) (car p) w
+                        (match (cdr e) (cdr p) w r))))
+      ((eq? p 'each-any)
+       (let ((l (match-each-any e w))) (and l (cons l r))))
+      (else
+       (case (vector-ref p 0)
+         ((each)
+          (if (null? e)
+              (match-empty (vector-ref p 1) r)
+              (let ((r* (match-each e (vector-ref p 1) w)))
+                (and r* (combine r* r)))))
+         ((free-id) (and (id? e) (literal-id=? (wrap e w) (vector-ref p 1)) r))
+         ((each+)
+          (let-values (((xr* y-pat r)
+                        (match-each+ e (vector-ref p 1) (vector-ref p 2)
+                          (vector-ref p 3) w r)))
+            (and r (null? y-pat)
+              (if (null? xr*)
+                  (match-empty (vector-ref p 1) r)
+                  (combine xr* r)))))
+         ((atom) (and (equal? (vector-ref p 1) (strip e w)) r))
+         ((vector)
+          (and (vector? e)
+               (match (vector->list e) (vector-ref p 1) w r))))))))
+
+(define match
+  (lambda (e p w r)
+    (cond
+      ((not r) #f)
+      ((eq? p 'any) (cons (wrap e w) r))
+      ((syntax-object? e)
+       (match*
+         (unannotate (syntax-object-expression e))
+         p
+         (join-wraps w (syntax-object-wrap e))
+         r))
+      (else (match* (unannotate e) p w r)))))
+
+(primitive-set! '$syntax-dispatch
+  (lambda (e p)
+    (cond
+      ((eq? p 'any) (list e))
+      ((syntax-object? e)
+       (match* (unannotate (syntax-object-expression e))
+         p (syntax-object-wrap e) '()))
+      (else (match* (unannotate e) p empty-wrap '())))))
+))
+
+
+(define-syntax with-syntax
+   (lambda (x)
+      (syntax-case x ()
+         ((_ () e1 e2 ...)
+          (syntax (begin e1 e2 ...)))
+         ((_ ((out in)) e1 e2 ...)
+          (syntax (syntax-case in () (out (begin e1 e2 ...)))))
+         ((_ ((out in) ...) e1 e2 ...)
+          (syntax (syntax-case (list in ...) ()
+                     ((out ...) (begin e1 e2 ...))))))))
+
+(define-syntax with-implicit
+  (syntax-rules ()
+    ((_ (tid id ...) e1 e2 ...)
+     (andmap identifier? (syntax (tid id ...)))
+     (begin
+       (unless (identifier? (syntax tid))
+         (syntax-error (syntax tid) "non-identifier with-implicit template"))
+       (with-syntax ((id (datum->syntax-object (syntax tid) 'id)) ...)
+         e1 e2 ...)))))
+
+(define-syntax datum
+  (syntax-rules ()
+    ((_ x) (syntax-object->datum (syntax x)))))
+
+(define-syntax syntax-rules
+  (lambda (x)
+    (define clause
+      (lambda (y)
+        (syntax-case y ()
+          (((keyword . pattern) template)
+           (syntax ((dummy . pattern) (syntax template))))
+          (((keyword . pattern) fender template)
+           (syntax ((dummy . pattern) fender (syntax template))))
+          (_ (syntax-error x)))))
+    (syntax-case x ()
+      ((_ (k ...) cl ...)
+       (andmap identifier? (syntax (k ...)))
+       (with-syntax (((cl ...) (map clause (syntax (cl ...)))))
+         (syntax (lambda (x) (syntax-case x (k ...) cl ...))))))))
+
+(define-syntax or
+   (lambda (x)
+      (syntax-case x ()
+         ((_) (syntax #f))
+         ((_ e) (syntax e))
+         ((_ e1 e2 e3 ...)
+          (syntax (let ((t e1)) (if t t (or e2 e3 ...))))))))
+
+(define-syntax and
+   (lambda (x)
+      (syntax-case x ()
+         ((_ e1 e2 e3 ...) (syntax (if e1 (and e2 e3 ...) #f)))
+         ((_ e) (syntax e))
+         ((_) (syntax #t)))))
+
+(define-syntax let
+   (lambda (x)
+      (syntax-case x ()
+         ((_ ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (x ...)))
+          (syntax ((lambda (x ...) e1 e2 ...) v ...)))
+         ((_ f ((x v) ...) e1 e2 ...)
+          (andmap identifier? (syntax (f x ...)))
+          (syntax ((letrec ((f (lambda (x ...) e1 e2 ...))) f)
+                    v ...))))))
+
+(define-syntax let*
+  (lambda (x)
+    (syntax-case x ()
+      ((let* ((x v) ...) e1 e2 ...)
+       (andmap identifier? (syntax (x ...)))
+       (let f ((bindings (syntax ((x v)  ...))))
+         (if (null? bindings)
+             (syntax (let () e1 e2 ...))
+             (with-syntax ((body (f (cdr bindings)))
+                           (binding (car bindings)))
+               (syntax (let (binding) body)))))))))
+
+(define-syntax cond
+  (lambda (x)
+    (syntax-case x ()
+      ((_ m1 m2 ...)
+       (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+         (if (null? clauses)
+             (syntax-case clause (else =>)
+               ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+               ((e0) (syntax (let ((t e0)) (if t t))))
+               ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
+               ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...))))
+               (_ (syntax-error x)))
+             (with-syntax ((rest (f (car clauses) (cdr clauses))))
+               (syntax-case clause (else =>)
+                 ((e0) (syntax (let ((t e0)) (if t t rest))))
+                 ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
+                 ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...) rest)))
+                 (_ (syntax-error x))))))))))
+
+(define-syntax do
+   (lambda (orig-x)
+      (syntax-case orig-x ()
+         ((_ ((var init . step) ...) (e0 e1 ...) c ...)
+          (with-syntax (((step ...)
+                         (map (lambda (v s)
+                                 (syntax-case s ()
+                                    (() v)
+                                    ((e) (syntax e))
+                                    (_ (syntax-error orig-x))))
+                              (syntax (var ...))
+                              (syntax (step ...)))))
+             (syntax-case (syntax (e1 ...)) ()
+                (() (syntax (let do ((var init) ...)
+                               (if (not e0)
+                                   (begin c ... (do step ...))))))
+                ((e1 e2 ...)
+                 (syntax (let do ((var init) ...)
+                            (if e0
+                                (begin e1 e2 ...)
+                                (begin c ... (do step ...))))))))))))
+
+(define-syntax quasiquote
+   (letrec
+     ; these are here because syntax-case uses literal-identifier=?,
+     ; and we want the more precise free-identifier=?
+      ((isquote? (lambda (x)
+                   (and (identifier? x)
+                        (free-identifier=? x (syntax quote)))))
+       (islist? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax list)))))
+       (iscons? (lambda (x)
+                  (and (identifier? x)
+                       (free-identifier=? x (syntax cons)))))
+       (quote-nil? (lambda (x)
+                    (syntax-case x ()
+                      ((quote? ()) (isquote? (syntax quote?)))
+                      (_ #f))))
+       (quasilist*
+        (lambda (x y)
+          (let f ((x x))
+            (if (null? x)
+                y
+                (quasicons (car x) (f (cdr x)))))))
+       (quasicons
+        (lambda (x y)
+          (with-syntax ((x x) (y y))
+            (syntax-case (syntax y) ()
+              ((quote? dy)
+               (isquote? (syntax quote?))
+               (syntax-case (syntax x) ()
+                 ((quote? dx)
+                  (isquote? (syntax quote?))
+                  (syntax (quote (dx . dy))))
+                 (_ (if (null? (syntax dy))
+                        (syntax (list x))
+                        (syntax (cons x y))))))
+              ((listp . stuff)
+               (islist? (syntax listp))
+               (syntax (list x . stuff)))
+              (else (syntax (cons x y)))))))
+       (quasiappend
+        (lambda (x y)
+          (let ((ls (let f ((x x))
+                      (if (null? x)
+                          (if (quote-nil? y)
+                              '()
+                              (list y))
+                          (if (quote-nil? (car x))
+                              (f (cdr x))
+                              (cons (car x) (f (cdr x))))))))
+            (cond
+              ((null? ls) (syntax (quote ())))
+              ((null? (cdr ls)) (car ls))
+              (else (with-syntax (((p ...) ls))
+                      (syntax (append p ...))))))))
+       (quasivector
+        (lambda (x)
+          (with-syntax ((pat-x x))
+            (syntax-case (syntax pat-x) ()
+              ((quote? (x ...))
+               (isquote? (syntax quote?))
+               (syntax (quote #(x ...))))
+              (_ (let f ((x x) (k (lambda (ls) `(,(syntax vector) ,@ls))))
+                   (syntax-case x ()
+                     ((quote? (x ...))
+                      (isquote? (syntax quote?))
+                      (k (syntax ((quote x) ...))))
+                     ((listp x ...)
+                      (islist? (syntax listp))
+                      (k (syntax (x ...))))
+                     ((cons? x y)
+                      (iscons? (syntax cons?))
+                      (f (syntax y) (lambda (ls) (k (cons (syntax x) ls)))))
+                     (else
+                      (syntax (list->vector pat-x))))))))))
+       (vquasi
+        (lambda (p lev)
+           (syntax-case p ()
+              ((p . q)
+               (syntax-case #'p (unquote unquote-splicing)
+                 ((unquote p ...)
+                  (if (fx= lev 0)
+                      (quasilist* (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 ((unquote-splicing p ...)
+                  (if (fx= lev 0)
+                      (quasiappend (syntax (p ...)) (vquasi (syntax q) lev))
+                      (quasicons (quasicons (syntax (quote unquote-splicing))
+                                            (quasi (syntax (p ...)) (fx- lev 1)))
+                                 (vquasi (syntax q) lev))))
+                 (p (quasicons (quasi (syntax p) lev) (vquasi (syntax q) lev)))))
+              (() (syntax (quote ()))))))
+       (quasi
+        (lambda (p lev)
+           (syntax-case p (unquote unquote-splicing quasiquote)
+              ((unquote p)
+               (if (fx= lev 0)
+                   (syntax p)
+                   (quasicons (syntax (quote unquote))
+                              (quasi (syntax (p)) (fx- lev 1)))))
+              (((unquote p ...) . q)
+               (if (fx= lev 0)
+                   (quasilist* (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              (((unquote-splicing p ...) . q)
+               (if (fx= lev 0)
+                   (quasiappend (syntax (p ...)) (quasi (syntax q) lev))
+                   (quasicons (quasicons (syntax (quote unquote-splicing))
+                                         (quasi (syntax (p ...)) (fx- lev 1)))
+                              (quasi (syntax q) lev))))
+              ((quasiquote p)
+               (quasicons (syntax (quote quasiquote))
+                          (quasi (syntax (p)) (fx+ lev 1))))
+              ((p . q)
+               (quasicons (quasi (syntax p) lev) (quasi (syntax q) lev)))
+              (#(x ...) (quasivector (vquasi (syntax (x ...)) lev)))
+              (p (syntax (quote p)))))))
+    (lambda (x)
+       (syntax-case x ()
+          ((_ e) (quasi (syntax e) 0))))))
+
+(define-syntax unquote
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unquote-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax quasisyntax
+  (lambda (x)
+    (define (qs q n b* k)
+      (syntax-case q (quasisyntax unsyntax unsyntax-splicing)
+        ((quasisyntax . d)
+         (qs #'d (fx+ n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(quasisyntax . d)))))))
+        ((unsyntax . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax . d)))))))
+        ((unsyntax-splicing . d)
+         (not (fx= n 0))
+         (qs #'d (fx- n 1) b*
+           (lambda (b* dnew)
+             (k b*
+                (if (eq? dnew #'d)
+                    q
+                    (with-syntax ((d dnew)) #'(unsyntax-splicing . d)))))))
+        ((unsyntax q)
+         (fx= n 0)
+         (with-syntax (((t) (generate-temporaries #'(q))))
+           (k (cons #'(t q) b*) #'t)))
+        (((unsyntax q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'((t q) ...) b*)
+                  (with-syntax ((d dnew)) #'(t ... . d)))))))
+        (((unsyntax-splicing q ...) . d)
+         (fx= n 0)
+         (qs #'d n b*
+           (lambda (b* dnew)
+             (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+               (k (append #'(((t (... ...)) q) ...) b*)
+                  (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                    (with-syntax ((d dnew)) #'(m ... ... . d))))))))
+        ((a . d)
+         (qs #'a n b*
+           (lambda (b* anew)
+             (qs #'d n b*
+               (lambda (b* dnew)
+                 (k b*
+                    (if (and (eq? anew #'a) (eq? dnew #'d))
+                        q
+                        (with-syntax ((a anew) (d dnew)) #'(a . d)))))))))
+        (#(x ...)
+         (vqs #'(x ...) n b*
+           (lambda (b* xnew*)
+             (k b*
+                (if (let same? ((x* #'(x ...)) (xnew* xnew*))
+                      (if (null? x*)
+                          (null? xnew*)
+                          (and (not (null? xnew*))
+                               (eq? (car x*) (car xnew*))
+                               (same? (cdr x*) (cdr xnew*)))))
+                    q
+                    (with-syntax (((x ...) xnew*)) #'#(x ...)))))))
+        (_ (k b* q))))
+    (define (vqs x* n b* k)
+      (if (null? x*)
+          (k b* '())
+          (vqs (cdr x*) n b*
+            (lambda (b* xnew*)
+              (syntax-case (car x*) (unsyntax unsyntax-splicing)
+                ((unsyntax q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'((t q) ...) b*)
+                      (append #'(t ...) xnew*))))
+                ((unsyntax-splicing q ...)
+                 (fx= n 0)
+                 (with-syntax (((t ...) (generate-temporaries #'(q ...))))
+                   (k (append #'(((t (... ...)) q) ...) b*)
+                      (with-syntax ((((m ...) ...) #'((t (... ...)) ...)))
+                        (append #'(m ... ...) xnew*)))))
+                (_ (qs (car x*) n b*
+                     (lambda (b* xnew)
+                       (k b* (cons xnew xnew*))))))))))
+    (syntax-case x ()
+      ((_ x)
+       (qs #'x 0 '()
+         (lambda (b* xnew)
+           (if (eq? xnew #'x)
+               #'(syntax x)
+               (with-syntax (((b ...) b*) (x xnew))
+                 #'(with-syntax (b ...) (syntax x))))))))))
+
+(define-syntax unsyntax
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax unsyntax-splicing
+  (lambda (x)
+    (syntax-error x "misplaced")))
+
+(define-syntax include
+  (lambda (x)
+    (define read-file
+      (lambda (fn k)
+        (let ((p (open-input-file fn)))
+          (let f ()
+            (let ((x (read p)))
+              (if (eof-object? x)
+                  (begin (close-input-port p) '())
+                  (cons (datum->syntax-object k x) (f))))))))
+    (syntax-case x ()
+      ((k filename)
+       (let ((fn (syntax-object->datum (syntax filename))))
+         (with-syntax (((exp ...) (read-file fn (syntax k))))
+           (syntax (begin exp ...))))))))
+
+(define-syntax case
+  (lambda (x)
+    (syntax-case x ()
+      ((_ e m1 m2 ...)
+       (with-syntax
+         ((body (let f ((clause (syntax m1)) (clauses (syntax (m2 ...))))
+                  (if (null? clauses)
+                      (syntax-case clause (else)
+                        ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
+                        (((k ...) e1 e2 ...)
+                         (syntax (if (memv t '(k ...)) (begin e1 e2 ...))))
+                        (_ (syntax-error x)))
+                      (with-syntax ((rest (f (car clauses) (cdr clauses))))
+                        (syntax-case clause (else)
+                          (((k ...) e1 e2 ...)
+                           (syntax (if (memv t '(k ...))
+                                       (begin e1 e2 ...)
+                                       rest)))
+                          (_ (syntax-error x))))))))
+         (syntax (let ((t e)) body)))))))
+
+(define-syntax identifier-syntax
+  (syntax-rules (set!)
+    ((_ e)
+     (lambda (x)
+       (syntax-case x ()
+         (id (identifier? (syntax id)) (syntax e))
+         ((_ x (... ...)) (syntax (e x (... ...)))))))
+    ((_ (id exp1) ((set! var val) exp2))
+     (and (identifier? (syntax id)) (identifier? (syntax var)))
+     (cons 'macro!
+       (lambda (x)
+         (syntax-case x (set!)
+           ((set! var val) (syntax exp2))
+           ((id x (... ...)) (syntax (exp1 x (... ...))))
+           (id (identifier? (syntax id)) (syntax exp1))))))))
+
+(define-syntax parameterize
+  (lambda (x)
+    (syntax-case x ()
+      [(_ () b b* ...) #'(let () b b* ...)]
+      [(_ ([olhs* orhs*] ...) b b* ...)
+       (with-syntax ([(lhs* ...) (generate-temporaries #'(olhs* ...))]
+                     [(rhs* ...) (generate-temporaries #'(orhs* ...))])
+        #'(let ([lhs* olhs*] ...
+                [rhs* orhs*] ...)
+            (let ([swap
+                   (lambda ()
+                     (let ([t (lhs*)])
+                       (lhs* rhs*)
+                       (set! rhs* t)) ...)])
+              (dynamic-wind
+                swap
+                (lambda () b b* ...)
+                swap))))])))
+
+(define-syntax when
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (begin b b* ...)
+         (void))]))
+
+(define-syntax unless
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (void)
+         (begin b b* ...))]))
+
+(define-syntax let-values
+  (lambda (x)
+    (define (bindem n** v**)
+      (syntax-case n** ()
+        [() #'()]
+        [((n* ...) . n**)
+         (syntax-case v** ()
+          [((v* ...) . v**)
+           (with-syntax ([rest (bindem #'n** #'v**)])
+             #'([n* v*] ... . rest))])]))
+    (syntax-case x ()
+      [(_ ([(name** ...) v*] ...) b b* ...)
+       (let ([n**
+              (let f ([n** #'((name** ...) ...)])
+                (syntax-case n** ()
+                  [() #'()]
+                  [(n* . n**)
+                   (with-syntax ([n* (generate-temporaries #'n*)]
+                                 [n** (f #'n**)])
+                     #'(n* . n**))]))])
+         (let f ([t** n**] [v* #'(v* ...)])
+           (syntax-case t** ()
+             [((t* ...) . t**) 
+              (syntax-case v* ()
+                [(v . v*)
+                 (with-syntax ([body (f #'t** #'v*)])
+                   #'(call-with-values
+                       (lambda () v)
+                       (lambda (t* ...) body)))])]
+             [() 
+              (with-syntax ([bind* (bindem #'((name** ...) ...) n**)])
+                #'(let bind* b b* ...))])))])))
+
+
+
+(define-syntax define-record
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append namestr "?")))]
+                       [(i ...)
+                        (datum->syntax-object #'name
+                          (let f ([i 0] [f* fieldstr*])
+                            (cond
+                              [(null? f*) '()]
+                              [else (cons i (f (fxadd1 i) (cdr f*)))])))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define constr 
+                  (lambda (field* ...)
+                    ($record 'rtd field* ...)))
+                (define pred
+                  (lambda (x) ($record/rtd? x 'rtd)))
+                (define getters 
+                  (lambda (x)
+                    (if ($record/rtd? x 'rtd) 
+                        ($record-ref x i)
+                        (error 'getters
+                               "~s is not a record of type ~s" x 'rtd)))) ...
+                (define setters 
+                  (lambda (x v)
+                    (if ($record/rtd? x 'rtd) 
+                        ($record-set! x i v)
+                        (error 'setters
+                               "~s is not a record of type ~s" x 'rtd)))) ...
+                )))])))
+
+(define-syntax $define-record-syntax
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append namestr "?")))]
+                       [(i ...)
+                        (datum->syntax-object #'name
+                          (let f ([i 0] [f* fieldstr*])
+                            (cond
+                              [(null? f*) '()]
+                              [else (cons i (f (fxadd1 i) (cdr f*)))])))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define-syntax constr
+                  (syntax-rules ()
+                    [(_ field* ...) ($record 'rtd field* ...)]))
+                (define-syntax pred
+                  (syntax-rules ()
+                    [(_ x) ($record/rtd? x 'rtd)]))
+                (define-syntax getters 
+                  (syntax-rules ()
+                    [(_ x) ($record-ref x i)])) ...
+                (define-syntax setters 
+                  (syntax-rules ()
+                    [(_ x v) ($record-set! x i v)])) ...
+                )))])))
+
+
+(define-syntax trace
+  (lambda (x)
+    (syntax-case x ()
+      [(_ id) (identifier? #'id)
+       #'(trace-symbol! 'id)])))
+
+
+(define-syntax untrace
+  (lambda (x)
+    (syntax-case x ()
+      [(_ id) (identifier? #'id)
+       #'(untrace-symbol! 'id)])))
+
+
+(define-syntax trace-lambda
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name args body body* ...)
+       #'(make-traced-procedure 'name (lambda args body body* ...))])))
+
diff --git a/src/psyntax-7.1.pp b/src/psyntax-7.1.pp
index 8020c5b..5e3922f 100644
--- a/src/psyntax-7.1.pp
+++ b/src/psyntax-7.1.pp
@@ -5,7 +5,7 @@
 
 (let ()
 (define + fx+)
-(define - fx-)
+;(define - fx-)
 (define * fx*)
 (define quotient fxquotient)
 (define modulo fxmodulo)
@@ -970,7 +970,7 @@
                                                        (cons
                                                          (car m12278)
                                                          (f2277
-                                                           (- n12279 '1)
+                                                           (fx- n12279 '1)
                                                            (cdr m12278)))
                                                        (if (equal?
                                                              m12278
@@ -3084,7 +3084,7 @@
                                                                                                                 (if t1893
                                                                                                                     t1893
                                                                                                                     (lp1891
-                                                                                                                      (- i1892
+                                                                                                                      (fx- i1892
                                                                                                                          '1))))
                                                                                                                ((lambda (id1894)
                                                                                                                   (help-bound-id=?432
@@ -3125,7 +3125,7 @@
                                                                                                                    i1892)))
                                                                                                              '#f))))
                                                                                         lp1891)
-                                                                                       (- (vector-length
+                                                                                       (fx- (vector-length
                                                                                             v1890)
                                                                                           '1)))
                                                                                     (interface-exports449
@@ -4080,7 +4080,7 @@
                                            (if (< i1704 '0)
                                                ls1703
                                                (do1702
-                                                 (- i1704 '1)
+                                                 (fx- i1704 '1)
                                                  (cons
                                                    (fn1701
                                                      (vector-ref
@@ -4088,7 +4088,7 @@
                                                        i1704))
                                                    ls1703))))))
                           do1702)
-                         (- (vector-length v1700) '1)
+                         (fx- (vector-length v1700) '1)
                          '())))
             (vfor-each483 (lambda (fn1696 v1695)
                             ((lambda (len1697)
@@ -6559,7 +6559,7 @@
                                                 (gen-ref1032
                                                   src1082
                                                   var1081
-                                                  (- level1080 '1)
+                                                  (fx- level1080 '1)
                                                   (cdr maps1079)))
                                               (lambda (outer-var1084
                                                        outer-maps1083)
@@ -9693,7 +9693,7 @@
                                                              '#(syntax-object (quote unquote) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))
                                                              (quasi2757
                                                                p2804
-                                                               (- lev2796
+                                                               (fx- lev2796
                                                                   '1)))
                                                            (vquasi2758
                                                              q2800
@@ -9715,7 +9715,7 @@
                                                                     '#(syntax-object (quote unquote-splicing) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))
                                                                     (quasi2757
                                                                       p2808
-                                                                      (- lev2796
+                                                                      (fx- lev2796
                                                                          '1)))
                                                                   (vquasi2758
                                                                     q2800
@@ -9766,7 +9766,7 @@
                                             '#(syntax-object (quote unquote) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))
                                             (quasi2757
                                               (list p2776)
-                                              (- lev2772 '1)))))
+                                              (fx- lev2772 '1)))))
                                     tmp2775)
                                   ((lambda (tmp2777)
                                      (if tmp2777
@@ -9783,7 +9783,7 @@
                                                      '#(syntax-object (quote unquote) ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))
                                                      (quasi2757
                                                        p2779
-                                                       (- lev2772 '1)))
+                                                       (fx- lev2772 '1)))
                                                    (quasi2757
                                                      q2778
                                                      lev2772))))
@@ -9803,7 +9803,7 @@
                                                             '#(syntax-object (quote unquote-splicing) ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))
                                                             (quasi2757
                                                               p2784
-                                                              (- lev2772
+                                                              (fx- lev2772
                                                                  '1)))
                                                           (quasi2757
                                                             q2783
@@ -9935,7 +9935,7 @@
                                           (lambda (d2960)
                                             (qs2899
                                               d2960
-                                              (- n2949 '1)
+                                              (fx- n2949 '1)
                                               b*2948
                                               (lambda (b*2962 dnew2961)
                                                 (k2947
@@ -9961,7 +9961,7 @@
                                                  (lambda (d2967)
                                                    (qs2899
                                                      d2967
-                                                     (- n2949 '1)
+                                                     (fx- n2949 '1)
                                                      b*2948
                                                      (lambda (b*2969
                                                               dnew2968)
diff --git a/src/psyntax-7.1.ss b/src/psyntax-7.1.ss
index 94b4550..f128c8c 100644
--- a/src/psyntax-7.1.ss
+++ b/src/psyntax-7.1.ss
@@ -569,6 +569,10 @@
 ;(define-syntax fx>= (identifier-syntax >=))
 
 (define annotation? (lambda (x) #f))
+(define annotation-expression 
+  (lambda (x) (error 'annotation-expression "not yet")))
+(define annotation-stripped 
+  (lambda (x) (error 'annotation-stripped "not yet")))
 
 ; top-level-eval-hook is used to create "permanent" code (e.g., top-level
 ; transformers), so it might be a good idea to compile it
@@ -651,7 +655,7 @@
 ;        (lambda (name) ; name is #f or a symbol
 ;          (set! n (+ n 1))
 ;          (string->symbol (string-append session-key (fmt n))))))))
-
+;;; AZIZ
 (define generate-id
   (lambda (name)
     (if name (gensym (symbol->string name)) (gensym))))
@@ -740,6 +744,10 @@
     [(_ ae vars exp)
      `(case-lambda [,vars ,exp])]))
 
+(define build-case-lambda
+  (lambda (ae vars* exp*)
+    `(case-lambda . ,(map list vars* exp*))))
+
 ;;; AZIZ
 ;;; (define built-lambda?
 ;;;   (lambda (x)
@@ -758,6 +766,15 @@
     [(_ ae name)       `(|#primitive| ,name)]
     [(_ ae level name) `(|#primitive| ,name)]))
 
+
+;;; AZIZ
+(define-syntax build-foreign-call
+  (syntax-rules ()
+    [(_ ae name arg*) `(foreign-call ,name . ,arg*)]))
+(define-syntax build-$apply
+  (syntax-rules ()
+    [(_ ae proc arg*) `($apply ,proc . ,arg*)]))
+
 (define-syntax build-data
   (syntax-rules ()
     ((_ ae exp) `',exp)))
@@ -929,15 +946,16 @@
       ((procedure? b) (make-binding 'macro b))
       ((binding? b)
        (and (case (binding-type b)
-              ((core macro macro! deferred) (and (procedure? (binding-value b))))
+              ((core macro macro! deferred)
+               (and (procedure? (binding-value b))))
               (($module) (interface? (binding-value b)))
               ((lexical) (lexical-var? (binding-value b)))
-             ((global meta-variable) (symbol? (binding-value b)))
+              ((global meta-variable) (symbol? (binding-value b)))
               ((syntax) (let ((x (binding-value b)))
                           (and (pair? x)
                                (lexical-var? (car x))
                                (let ((n (cdr x)))
-                                 (and (integer? n) (exact? n) (fx>= n 0))))))
+                                 (and (fixnum? n) (fx>= n 0))))))
               ((begin define define-syntax set! $module-key $import eval-when meta) (null? (binding-value b)))
               ((local-syntax) (boolean? (binding-value b)))
               ((displaced-lexical) (eq? (binding-value b) #f))
@@ -949,6 +967,7 @@
   (syntax-rules (quote)
     ((_ 'type #f) '(type . #f))
     ((_ type value) (cons type value))))
+
 (define binding-type car)
 (define binding-value cdr)
 (define set-binding-type! set-car!)
@@ -2408,6 +2427,7 @@
           (unless t (set! t (thunk)))
           (top-level-eval-hook t))
         (lambda () (or t (thunk)))))))
+
 (define ct-eval/residualize3
   (lambda (ctem eval-thunk residualize-thunk)
     (if (memq 'E ctem)
@@ -2545,6 +2565,9 @@
                 e w ae))))))
       (_ (syntax-error (source-wrap e w ae))))))
 
+
+
+
 (define chi-macro
   (lambda (p e r w ae rib)
     (define rebuild-macro-output
@@ -3203,7 +3226,7 @@
                    ,@(map (let ((r (map cons formals actuals)))
                             (lambda (x) (cdr (assq (cadr x) r))))
                           (cdr e))))
-            (else `(map (lambda ,formals ,e) ,@actuals))))))
+            (else `(map (case-lambda [,formals ,e]) ,@actuals))))))
 
    ; 12/12/00: semantic change: we now return original syntax object (e)
    ; if no pattern variables were found within, to avoid dropping
@@ -3240,7 +3263,13 @@
           ((ref) (build-lexical-reference 'value no-source (cadr x)))
           ((primitive) (build-primref no-source (cadr x)))
           ((quote) (build-data no-source (cadr x)))
-          ((lambda) (build-lambda no-source (cadr x) (regen (caddr x))))
+          ((lambda) 
+           (build-lambda no-source (cadr x) (regen (caddr x))))
+          ((case-lambda)
+           (let ([d (cdr x)])
+             (build-case-lambda no-source
+              (map car d)
+              (map (lambda (x) (regen (cadr x))) d))))
           ((map) (let ((ls (map regen (cdr x))))
                    (build-application no-source
                      (if (fx= (length ls) 2)
@@ -3271,6 +3300,28 @@
                        (syntax c) r mr w m?)))
          (build-lambda ae vars body))))))
 
+;;; AZIZ
+(global-extend 'core 'case-lambda
+   (lambda (e r mr w ae m?)
+     (syntax-case e ()
+       [(_ c* ...)
+        (let-values ([(vars* body*)
+                      (let f ([c* #'(c* ...)])
+                        (syntax-case c* ()
+                          [() (values '() '())]
+                          [(c . c*) 
+                           (let-values ([(vars body)
+                                         (chi-lambda-clause
+                                           (source-wrap e w ae)
+                                           #'c r mr w m?)])
+                             (let-values ([(vars* body*) (f #'c*)])
+                               (values 
+                                 (cons vars vars*)
+                                 (cons body body*))))]))])
+           (build-case-lambda ae vars* body*))])))
+
+
+
 
 (global-extend 'core 'letrec
   (lambda (e r mr w ae m?)
@@ -3306,6 +3357,47 @@
              (chi (syntax else) r mr w m?)))
          (_ (syntax-error (source-wrap e w ae))))))
 
+;;; AZIZ
+(global-extend 'core 'foreign-call
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-foreign-call ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+(global-extend 'core '$apply
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      [(_ proc arg* ...)
+       (build-$apply ae
+         (chi #'proc r mr w m?)
+         (let f ([arg* #'(arg* ...)])
+           (syntax-case arg* ()
+             [() '()]
+             [(a . arg*)
+              (cons (chi #'a r mr w m?)
+                    (f #'arg*))])))]
+      [_ (syntax-error (source-wrap e w ae))])))
+
+;;; AZIZ
+(global-extend 'core 'type-descriptor
+  (lambda (e r mr w ae m?)
+    (syntax-case e ()
+      ((_ id)
+       (id? (syntax id))
+       (let ((n (id-var-name (syntax id) w)))
+         (let ((b (lookup n r)))
+           (case (binding-type b)
+             (($rtd) 
+              (build-data ae (binding-value b)))
+             (else (syntax-error (source-wrap e w ae)))))))
+      (_ (syntax-error (source-wrap e w ae))))))
 
 
 (global-extend 'set! 'set! '())
@@ -3755,8 +3847,17 @@
                 ctem rtem #f
                 (env-top-ribcage env))))))))
 
+(primitive-set! 'current-expand
+  (make-parameter
+    sc-expand
+    (lambda (x)
+      (unless (procedure? x)
+        (error 'current-expand "~s is not a procedure" x))
+      x)))
 
-
+(primitive-set! 'expand
+  (lambda (x)
+    ((current-expand) x)))
 
 (primitive-set! '$make-environment
   (lambda (token mutable?)
@@ -3977,7 +4078,7 @@
          r))
       (else (match* (unannotate e) p w r)))))
 
-(set! $syntax-dispatch
+(primitive-set! '$syntax-dispatch
   (lambda (e p)
     (cond
       ((eq? p 'any) (list e))
@@ -4418,7 +4519,90 @@
                 (lambda () b b* ...)
                 swap))))])))
 
+(define-syntax when
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (begin b b* ...)
+         (void))]))
+
+(define-syntax unless
+  (syntax-rules ()
+    [(_ test b b* ...)
+     (if test 
+         (void)
+         (begin b b* ...))]))
+
+(define-syntax let-values
+  (lambda (x)
+    (define (bindem n** v**)
+      (syntax-case n** ()
+        [() #'()]
+        [((n* ...) . n**)
+         (syntax-case v** ()
+          [((v* ...) . v**)
+           (with-syntax ([rest (bindem #'n** #'v**)])
+             #'([n* v*] ... . rest))])]))
+    (syntax-case x ()
+      [(_ ([(name** ...) v*] ...) b b* ...)
+       (let ([n**
+              (let f ([n** #'((name** ...) ...)])
+                (syntax-case n** ()
+                  [() #'()]
+                  [(n* . n**)
+                   (with-syntax ([n* (generate-temporaries #'n*)]
+                                 [n** (f #'n**)])
+                     #'(n* . n**))]))])
+         (let f ([t** n**] [v* #'(v* ...)])
+           (syntax-case t** ()
+             [((t* ...) . t**) 
+              (syntax-case v* ()
+                [(v . v*)
+                 (with-syntax ([body (f #'t** #'v*)])
+                   #'(call-with-values
+                       (lambda () v)
+                       (lambda (t* ...) body)))])]
+             [() 
+              (with-syntax ([bind* (bindem #'((name** ...) ...) n**)])
+                #'(let bind* b b* ...))])))])))
 
 
 
 
+(define-syntax define-record
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append namestr "?")))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define constr (record-constructor 'rtd))
+                (define pred (record-predicate 'rtd))
+                (define getters (record-field-accessor 'rtd 'field*)) ...
+                (define setters (record-field-mutator 'rtd 'field*)) ...
+                )))])))
+
diff --git a/src/record-case.chez.ss b/src/record-case.chez.ss
new file mode 100644
index 0000000..0f01367
--- /dev/null
+++ b/src/record-case.chez.ss
@@ -0,0 +1,26 @@
+
+(define-syntax record-case
+  (lambda (x)
+    (define (enumerate fld* i)
+      (syntax-case fld* ()
+       [() #'()]
+       [(x . x*) 
+        (with-syntax ([i i] [i* (enumerate #'x* (fx+ i 1))])
+          #'(i . i*))]))
+    (define (generate-body ctxt cls*)
+      (syntax-case cls* (else)
+       [() (with-syntax ([x x]) #'(error #f "unmatched ~s in ~s" v #'x))]
+       [([else b b* ...])  #'(begin b b* ...)]
+       [([(rec-name rec-field* ...) b b* ...] . rest) (identifier? #'rec-name)
+        (with-syntax ([altern (generate-body ctxt #'rest)]
+                      [(id* ...) (enumerate #'(rec-field* ...) 0)]
+                      [rtd #'(type-descriptor rec-name)])
+         #'(if ((record-predicate rtd) v)
+               (let ([rec-field* ;($record-ref v id*)] ...)
+                      ((record-field-accessor rtd id*) v)] ...)
+                 b b* ...)
+               altern))]))
+    (syntax-case x ()
+     [(_ expr cls* ...)
+      (with-syntax ([body (generate-body #'_ #'(cls* ...))])
+        #'(let ([v expr]) body))])))
diff --git a/src/record-case.ss b/src/record-case.ss
index b928871..99d8065 100644
--- a/src/record-case.ss
+++ b/src/record-case.ss
@@ -1,12 +1,11 @@
 
 (define-syntax record-case
   (lambda (x)
-    (import scheme)
     (define (enumerate fld* i)
       (syntax-case fld* ()
        [() #'()]
        [(x . x*) 
-        (with-syntax ([i i] [i* (enumerate #'x* (add1 i))])
+        (with-syntax ([i i] [i* (enumerate #'x* (fx+ i 1))])
           #'(i . i*))]))
     (define (generate-body ctxt cls*)
       (syntax-case cls* (else)
@@ -16,9 +15,10 @@
         (with-syntax ([altern (generate-body ctxt #'rest)]
                       [(id* ...) (enumerate #'(rec-field* ...) 0)]
                       [rtd #'(type-descriptor rec-name)])
-         #'(if ((record-predicate rtd) v)
-               (let ([rec-field* 
-                      ((record-field-accessor rtd id*) v)] ...)
+         #'(if ($record/rtd? v rtd)
+             ;((record-predicate rtd) v)
+               (let ([rec-field* ($record-ref v id*)] ...)
+                     ; ((record-field-accessor rtd id*) v)] ...)
                  b b* ...)
                altern))]))
     (syntax-case x ()
diff --git a/src/runtime/Makefile b/src/runtime/Makefile
index 5ec374c..55c9172 100644
--- a/src/runtime/Makefile
+++ b/src/runtime/Makefile
@@ -1,40 +1,41 @@
 
 #CFLAGS = -Wall -DNDEBUG -O3
 CFLAGS = -Wall -g
-LDFLAGS = -g -ldl -luuid -rdynamic
+LDFLAGS = -g -ldl -rdynamic
+CC = gcc
 all: ikarus
 
 ikarus: ikarus-collect.o ikarus-runtime.o ikarus-main.o ikarus-fasl.o \
   ikarus-exec.o ikarus-print.o ikarus-enter.s ikarus-symbol-table.o  \
   ikarus-weak-pairs.o
-	gcc  $(LDFLAGS) -o ikarus \
+	$(CC)  $(LDFLAGS) -o ikarus \
 	ikarus-main.o ikarus-runtime.o \
 	ikarus-fasl.o ikarus-exec.o ikarus-print.o ikarus-enter.s \
 	ikarus-symbol-table.o ikarus-collect.o ikarus-weak-pairs.o
 
 ikarus-main.o: ikarus-main.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-main.c
+	$(CC) $(CFLAGS) -c ikarus-main.c
 
 ikarus-runtime.o: ikarus-runtime.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-runtime.c
+	$(CC) $(CFLAGS) -c ikarus-runtime.c
 
 ikarus-fasl.o: ikarus-fasl.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-fasl.c
+	$(CC) $(CFLAGS) -c ikarus-fasl.c
 
 ikarus-exec.o: ikarus-exec.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-exec.c
+	$(CC) $(CFLAGS) -c ikarus-exec.c
 
 ikarus-print.o: ikarus-print.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-print.c
+	$(CC) $(CFLAGS) -c ikarus-print.c
 
 ikarus-collect.o: ikarus-collect.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-collect.c
+	$(CC) $(CFLAGS) -c ikarus-collect.c
 
 ikarus-weak-pairs.o: ikarus-weak-pairs.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-weak-pairs.c
+	$(CC) $(CFLAGS) -c ikarus-weak-pairs.c
 
 ikarus-symbol-table.o: ikarus-symbol-table.c ikarus.h
-	gcc $(CFLAGS) -c ikarus-symbol-table.c
+	$(CC) $(CFLAGS) -c ikarus-symbol-table.c
 
 ikarus.h: ikarus-data.h
 	touch ikarus.h
diff --git a/src/runtime/ikarus b/src/runtime/ikarus
index d50d625..51ed093 100755
Binary files a/src/runtime/ikarus and b/src/runtime/ikarus differ
diff --git a/src/runtime/ikarus-collect.c b/src/runtime/ikarus-collect.c
index 6a89861..487aa3c 100644
--- a/src/runtime/ikarus-collect.c
+++ b/src/runtime/ikarus-collect.c
@@ -8,6 +8,7 @@
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <assert.h>
+#include <errno.h>
 
 #define forward_ptr ((ikp)-1)
 #define DEBUG_STACK 0
@@ -45,12 +46,14 @@ typedef struct{
 #define meta_code 1
 #define meta_data 2
 #define meta_weak 3
-#define meta_count 4
+#define meta_pair 4
+#define meta_count 5
 
 static int extension_amount[meta_count] = {
   4 * pagesize,
   1 * pagesize,
   4 * pagesize,
+  1 * pagesize,
   1 * pagesize
 };
 
@@ -58,7 +61,8 @@ static unsigned int meta_mt[meta_count] = {
   pointers_mt,
   code_mt,
   data_mt,
-  weak_pairs_mt
+  weak_pairs_mt,
+  pointers_mt
 };
 
 #define generation_count 5  /* generations 0 (nursery), 1, 2, 3, 4 */
@@ -85,10 +89,6 @@ next_gen_tag[generation_count] = {
   (0 << meta_dirty_shift) | 4 | new_gen_tag
 };
 
-
-
-
-
 static ikp
 meta_alloc_extending(int size, int old_gen, gc_t* gc, int meta_id){
   int mapsize = align_to_next_page(size);
@@ -149,9 +149,33 @@ gc_alloc_new_ptr(int size, int old_gen, gc_t* gc){
 }
 
 static inline ikp 
-gc_alloc_new_weak_ptr(int size, int old_gen, gc_t* gc){
-  assert(size == align(size));
-  return meta_alloc(size, old_gen, gc, meta_weak);
+gc_alloc_new_pair(int old_gen, gc_t* gc){
+  return meta_alloc(pair_size, old_gen, gc, meta_pair);
+}
+
+
+
+static inline ikp 
+gc_alloc_new_weak_pair(int old_gen, gc_t* gc){
+  meta_t* meta = &gc->meta[old_gen][meta_weak];
+  ikp ap = meta->ap;
+  ikp ep = meta->ep;
+  ikp nap = ap + pair_size;
+  if(nap > ep){
+      ikp mem = ik_mmap_typed(
+                   pagesize, 
+                   meta_mt[meta_weak] | next_gen_tag[old_gen],
+                   gc->pcb);
+      gc->segment_vector = gc->pcb->segment_vector;
+      meta->ap = mem + pair_size;
+      meta->aq = mem;
+      meta->ep = mem + pagesize;
+      meta->base = mem;
+      return mem;
+  } else {
+    meta->ap = nap;
+    return ap;
+  }
 }
 
 static inline ikp 
@@ -162,7 +186,19 @@ gc_alloc_new_data(int size, int old_gen, gc_t* gc){
 
 static inline ikp 
 gc_alloc_new_code(int size, int old_gen, gc_t* gc){
-  return meta_alloc(size, old_gen, gc, meta_code);
+  if(size < pagesize){
+    return meta_alloc(size, old_gen, gc, meta_code);
+  } else {
+    int memreq = align_to_next_page(size);
+    ikp mem = ik_mmap_code(memreq, next_gen_tag[old_gen], gc->pcb);
+    gc->segment_vector = gc->pcb->segment_vector;
+    qupages_t* p = ik_malloc(sizeof(qupages_t));
+    p->p = mem;
+    p->q = mem+size;
+    p->next = gc->queues[meta_code];
+    gc->queues[meta_code] = p;
+    return mem;
+  }
 }
 
 static void
@@ -197,7 +233,6 @@ gc_tconc_push(gc_t* gc, ikp tcbucket){
 
 static ikp add_object(gc_t* gc, ikp x);
 static void collect_stack(gc_t*, ikp top, ikp base);
-static void collect_oblist(gc_t*, ikoblist*);
 static void collect_loop(gc_t*);
 static void fix_weak_pointers(gc_t*);
 static void gc_add_tconcs(gc_t*);
@@ -231,6 +266,8 @@ static int collection_id_to_gen(int id){
   return 0;
 }
 
+
+
 static void scan_dirty_pages(gc_t*);
 
 static void deallocate_unused_pages(gc_t*);
@@ -240,6 +277,11 @@ static void fix_new_pages(gc_t* gc);
 
 ikpcb* 
 ik_collect(int req, ikpcb* pcb){
+
+  struct rusage t0, t1;
+   
+  getrusage(RUSAGE_SELF, &t0);
+
   gc_t gc;
   bzero(&gc, sizeof(gc_t));
   gc.pcb = pcb;
@@ -248,8 +290,11 @@ ik_collect(int req, ikpcb* pcb){
   gc.collect_gen = collection_id_to_gen(pcb->collection_id);
   pcb->collection_id++;
 #ifndef NDEBUG
-  fprintf(stderr, "ik_collect entry %d (collect gen=%d/id=%d)\n",
-      req, gc.collect_gen, pcb->collection_id-1);
+  fprintf(stderr, "ik_collect entry %d free=%d (collect gen=%d/id=%d)\n",
+      req,
+      (unsigned int) pcb->allocation_redline
+        - (unsigned int) pcb->allocation_pointer,
+      gc.collect_gen, pcb->collection_id-1);
 #endif
 
 
@@ -262,7 +307,7 @@ ik_collect(int req, ikpcb* pcb){
   scan_dirty_pages(&gc);
   collect_stack(&gc, pcb->frame_pointer, pcb->frame_base - wordsize);
   pcb->next_k = add_object(&gc, pcb->next_k); 
-  collect_oblist(&gc, pcb->oblist);
+  pcb->oblist = add_object(&gc, pcb->oblist); 
   /* now we trace all live objects */
   collect_loop(&gc);
 
@@ -297,6 +342,33 @@ ik_collect(int req, ikpcb* pcb){
     htable_count = 0;
   }
   //ik_dump_metatable(pcb);
+#ifndef NDEBUG
+  fprintf(stderr, "collect done\n");
+#endif
+  getrusage(RUSAGE_SELF, &t1);
+  pcb->collect_utime.tv_usec += t1.ru_utime.tv_usec - t0.ru_utime.tv_usec;
+  pcb->collect_utime.tv_sec += t1.ru_utime.tv_sec - t0.ru_utime.tv_sec;
+  if (pcb->collect_utime.tv_usec >= 1000000){
+   pcb->collect_utime.tv_usec -= 1000000;
+   pcb->collect_utime.tv_sec += 1;
+  }
+  else if (pcb->collect_utime.tv_usec < 0){
+   pcb->collect_utime.tv_usec += 1000000;
+   pcb->collect_utime.tv_sec -= 1;
+  }
+ 
+  pcb->collect_stime.tv_usec += t1.ru_stime.tv_usec - t0.ru_stime.tv_usec;
+  pcb->collect_stime.tv_sec += t1.ru_stime.tv_sec - t0.ru_stime.tv_sec;
+  if (pcb->collect_stime.tv_usec >= 1000000){
+   pcb->collect_stime.tv_usec -= 1000000;
+   pcb->collect_stime.tv_sec += 1;
+  }
+  else if (pcb->collect_stime.tv_usec < 0){
+   pcb->collect_stime.tv_usec += 1000000;
+   pcb->collect_stime.tv_sec -= 1;
+  }
+ 
+
   return pcb;
 }
 
@@ -355,34 +427,38 @@ add_code_entry(gc_t* gc, ikp entry){
   if(gen > gc->collect_gen){
     return entry;
   }
-  int code_size = (int)ref(x, disp_code_code_size);
-  int reloc_size = (int)ref(x, disp_code_reloc_size);
-  int closure_size = (int)ref(x, disp_code_closure_size);
-  int required_mem = align(disp_code_data + code_size + reloc_size);
-  ikp y = gc_alloc_new_code(required_mem, gen, gc);
-  ref(y, 0) = code_tag;
-  ref(y, disp_code_code_size) = (ikp)code_size;
-  ref(y, disp_code_reloc_size) = (ikp)reloc_size;
-  ref(y, disp_code_closure_size) = (ikp)closure_size;
-  ref(y, disp_code_data) = x;
-  ref(x, 0) = forward_ptr;
-  ref(x, wordsize) = y + vector_tag;
-  return y+disp_code_data;
-}
-
-static void collect_oblist(gc_t* gc, ikoblist* st){
-  ikbucket** p = st->buckets;
-  ikbucket** q = p + st->number_of_buckets;
-  while(p < q){
-    ikbucket* b = *p;
-    while(b){
-      b->val = add_object(gc, b->val);
-      b = b->next;
+  int code_size = unfix(ref(x, disp_code_code_size));
+  ikp reloc_vec = ref(x, disp_code_reloc_vector);
+  ikp freevars = ref(x, disp_code_freevars);
+  int required_mem = align(disp_code_data + code_size);
+  if(required_mem >= pagesize){
+    int new_tag = next_gen_tag[gen];
+    int idx = page_index(x);
+    gc->segment_vector[idx] = new_tag | code_mt;
+    int i;
+    for(i=pagesize, idx++; i<required_mem; i+=pagesize, idx++){
+      gc->segment_vector[idx] = new_tag | data_mt;
     }
-    p++;
+    qupages_t* p = ik_malloc(sizeof(qupages_t));
+    p->p = x;
+    p->q = x+required_mem;
+    p->next = gc->queues[meta_code];
+    gc->queues[meta_code] = p;
+    return entry;
+  } else {
+    ikp y = gc_alloc_new_code(required_mem, gen, gc);
+    ref(y, 0) = code_tag;
+    ref(y, disp_code_code_size) = fix(code_size);
+    ref(y, disp_code_reloc_vector) = reloc_vec;
+    ref(y, disp_code_freevars) = freevars;
+    memcpy(y+disp_code_data, x+disp_code_data, code_size);
+    ref(x, 0) = forward_ptr;
+    ref(x, wordsize) = y + vector_tag;
+    return y+disp_code_data;
   }
 }
 
+
 #define DEBUG_STACK 0
 
 static void collect_stack(gc_t* gc, ikp top, ikp end){
@@ -498,6 +574,60 @@ static void collect_stack(gc_t* gc, ikp top, ikp end){
   }
 }
 
+
+static void 
+add_list(gc_t* gc, unsigned int t, int gen, ikp x, ikp* loc){
+  int collect_gen = gc->collect_gen;
+  while(1){
+    ikp fst = ref(x, off_car);
+    ikp snd = ref(x, off_cdr);
+    ikp y;
+    if((t & type_mask) != weak_pairs_type){
+      y = gc_alloc_new_pair(gen, gc) + pair_tag;
+    } else {
+      y = gc_alloc_new_weak_pair(gen, gc) + pair_tag;
+    }
+    *loc = y;
+    ref(x,off_car) = forward_ptr;
+    ref(x,off_cdr) = y;
+    ref(y,off_car) = fst;
+    int stag = tagof(snd);
+    if(stag == pair_tag){
+      if(ref(snd, -pair_tag) == forward_ptr){
+        ref(y, off_cdr) = ref(snd, wordsize-pair_tag);
+        return;
+      } 
+      else {
+        t = gc->segment_vector[page_index(snd)];
+        gen = t & gen_mask;
+        if(gen > collect_gen){
+          ref(y, off_cdr) = snd;
+          return;
+        } else {
+          x = snd;
+          loc = (ikp*)(y + off_cdr);
+          /* don't return */
+        }
+      }
+    }
+    else if(   (stag == immediate_tag)
+            || (stag == 0) 
+            || (stag == (1<<fx_shift))) {
+      ref(y,off_cdr) = snd;
+      return;
+    }
+    else if (ref(snd, -stag) == forward_ptr){
+      ref(y, off_cdr) = ref(snd, wordsize-stag);
+      return;
+    }
+    else {
+      ref(y, off_cdr) = add_object(gc, snd);
+      return;
+    }
+  }
+}
+
+
 static ikp 
 add_object(gc_t* gc, ikp x){
   if(is_fixnum(x)){ 
@@ -522,20 +652,8 @@ add_object(gc_t* gc, ikp x){
     return x;
   }
   if(tag == pair_tag){
-    ikp snd = ref(x, off_cdr);
     ikp y;
-    if((t & type_mask) == weak_pairs_type){
-      y = gc_alloc_new_weak_ptr(pair_size, gen, gc) + pair_tag;
-    } else {
-      y = gc_alloc_new_ptr(pair_size, gen, gc) + pair_tag;
-    }
-    ref(y,off_car) = fst;
-    ref(y,off_cdr) = snd;
-    ref(x,off_car) = forward_ptr;
-    ref(x,off_cdr) = y;
-    if(accounting){
-      pair_count++;
-    }
+    add_list(gc, t, gen, x, &y);
     return y;
   }
   else if(tag == symbol_tag){
@@ -554,17 +672,14 @@ add_object(gc_t* gc, ikp x){
     return y;
   }
   else if(tag == closure_tag){
-    int size = (int) ref(fst, disp_code_closure_size - disp_code_data);
-    if(size <= 0){
-      fprintf(stderr, "invalid closure size=%d\n", size);
-      exit(-1);
-    }
+    int size = disp_closure_data+
+              (int) ref(fst, disp_code_freevars - disp_code_data);
     if(size > 1024){
       fprintf(stderr, "large closure size=0x%08x\n", size);
     }
     int asize = align(size);
     ikp y = gc_alloc_new_ptr(asize, gen, gc) + closure_tag;
-    bzero(y-closure_tag, asize);
+    ref(y, asize-closure_tag-wordsize) = 0;
     memcpy(y-closure_tag, x-closure_tag, size);
     ref(y,-closure_tag) = add_code_entry(gc, ref(y,-closure_tag));
     ref(x,-closure_tag) = forward_ptr;
@@ -578,13 +693,12 @@ add_object(gc_t* gc, ikp x){
     if(is_fixnum(fst)){
       /* real vector */
       int size = (int)fst;
-      if(size > 4096){
-        fprintf(stderr, "large vec size=0x%08x\n", size);
-      }
+      assert(size >= 0);
       int memreq = align(size + disp_vector_data);
       ikp y = gc_alloc_new_ptr(memreq, gen, gc) + vector_tag;
-      bzero(y-vector_tag, memreq);
-      memcpy(y-vector_tag, x-vector_tag, size + disp_vector_data);
+      ref(y, disp_vector_length-vector_tag) = fst;
+      ref(y, memreq-vector_tag-wordsize) = 0;
+      memcpy(y+off_vector_data, x+off_vector_data, size);
       ref(x,-vector_tag) = forward_ptr;
       ref(x,wordsize-vector_tag) = y;
       if(accounting){
@@ -600,7 +714,7 @@ add_object(gc_t* gc, ikp x){
       }
       int memreq = align(size + disp_record_data);
       ikp y = gc_alloc_new_ptr(memreq, gen, gc) + vector_tag;
-      bzero(y-vector_tag, memreq);
+      ref(y, memreq-vector_tag-wordsize) = 0;
       memcpy(y-vector_tag, x-vector_tag, size+wordsize);
       ref(x,-vector_tag) = forward_ptr;
       ref(x,wordsize-vector_tag) = y;
@@ -615,7 +729,6 @@ add_object(gc_t* gc, ikp x){
       return new_entry - off_code_data;
     } 
     else if(fst == continuation_tag){
-//      fprintf(stderr, "conitnuation!\n");
       ikp top = ref(x, off_continuation_top);
       int size = (int) ref(x, off_continuation_size);
       if(size > 4096){
@@ -664,9 +777,6 @@ add_object(gc_t* gc, ikp x){
   else if(tag == string_tag){
     if(is_fixnum(fst)){
       int strlen = unfix(fst);
-      if(strlen > 4096){
-        fprintf(stderr, "large string size=0x%08x\n", strlen);
-      }
       int memreq = align(strlen + disp_string_data + 1);
       ikp new_str = gc_alloc_new_data(memreq, gen, gc) + string_tag;
       ref(new_str, off_string_length) = fst;
@@ -692,65 +802,49 @@ add_object(gc_t* gc, ikp x){
 
 static void
 relocate_new_code(ikp x, gc_t* gc){
-  int instrsize = (int)ref(x, disp_code_code_size);
-  int relocsize = (int)ref(x, disp_code_reloc_size);
-  ikp y = ref(x, disp_code_data);
-  assert(ref(y, 0) == forward_ptr);
-  assert(ref(y, wordsize) == (x+vector_tag));
-  memcpy(x+disp_code_data, y+disp_code_data, instrsize+relocsize);
-  ikp reloc = x + disp_code_data + instrsize;
-  int i = 0;
-  while(i < relocsize){
-    int r = (int) ref(reloc,i);
-    if(r == 0){
-      i = relocsize;
+  ikp relocvector = ref(x, disp_code_reloc_vector);
+  relocvector = add_object(gc, relocvector);
+  ref(x, disp_code_reloc_vector) = relocvector;
+  int relocsize = (int)ref(relocvector, off_vector_length);
+  ikp p = relocvector + off_vector_data;
+  ikp q = p + relocsize;
+  ikp code = x + disp_code_data;
+  while(p < q){
+    int r = unfix(ref(p, 0));
+    int tag = r & 3;
+    int code_off = r >> 2;
+    if(tag == 0){
+      /* undisplaced pointer */
+      ikp old_object = ref(p, wordsize);
+      ikp new_object = add_object(gc, old_object);
+      ref(code, code_off) = new_object;
+      p += (2*wordsize);
+    }
+    else if(tag == 2){
+      /* displaced pointer */
+      int obj_off = unfix(ref(p, wordsize));
+      ikp old_object = ref(p, 2*wordsize);
+      ikp new_object = add_object(gc, old_object);
+      ref(code, code_off) = new_object + obj_off;
+      p += (3 * wordsize);
+    } 
+    else if(tag == 3){
+      /* displaced relative pointer */
+      int obj_off = unfix(ref(p, wordsize));
+      ikp obj = add_object(gc, ref(p, 2*wordsize));
+      ikp displaced_object = obj + obj_off;
+      ikp next_word = code + code_off + wordsize;
+      ikp relative_distance = displaced_object - (int)next_word;
+      ref(next_word, -wordsize) = relative_distance;
+      p += (3*wordsize);
+    }
+    else if(tag == 1){
+      /* do nothing */
+      p += (2 * wordsize);
     }
     else {
-      int rtag = r & 3;
-      if(rtag == 0){
-        /* undisplaced pointer */
-        int code_offset = r >> 2;
-        ikp old_object = ref(x, disp_code_data + code_offset);
-        ikp new_object = add_object(gc, old_object);
-        ref(x, disp_code_data + code_offset) = new_object;
-        i += wordsize;
-      }
-      else if(rtag == 1){
-        /* displaced pointer */
-        int code_offset = r >> 2;
-        int object_offset = (int) ref(reloc, i + wordsize);
-        ikp old_displaced_object = ref(x, disp_code_data + code_offset);
-        ikp old_object = old_displaced_object - object_offset;
-        ikp new_object = add_object(gc, old_object);
-        ikp new_displaced_object = new_object + object_offset;
-        ref(x, disp_code_data + code_offset) = new_displaced_object;
-        i += (2 * wordsize);
-      } 
-      else if(rtag == 2){
-        /* displaced relative pointer */
-        int code_offset = r >> 2;
-        int object_offset = (int) ref(reloc, i+wordsize);
-        ikp old_relative_pointer = ref(x, disp_code_data + code_offset);
-        ikp old_next_word = y + disp_code_data + code_offset + wordsize;
-        ikp old_absolute_pointer = old_relative_pointer + (int)old_next_word;
-        ikp old_object = old_absolute_pointer - object_offset;
-        ikp new_object = add_object(gc, old_object);
-        ikp new_absolute_pointer = new_object + object_offset;
-        ikp new_next_word = x + disp_code_data + code_offset + wordsize;
-        ikp new_relative_pointer = new_absolute_pointer - (int) new_next_word;
-        ref(x, disp_code_data+code_offset) = new_relative_pointer;
-        i += (2*wordsize);
-      }
-      else if(rtag == 3){
-        /* foreign object */
-        /* just add the name */
-        ref(reloc, i+wordsize) = add_object(gc, ref(reloc, i+wordsize));
-        i += (2 * wordsize);
-      }
-      else {
-        fprintf(stderr, "invalid rtag %d in 0x%08x\n", rtag, r);
-        exit(-1);
-      }
+      fprintf(stderr, "invalid rtag %d in 0x%08x\n", tag, r);
+      exit(-1);
     } 
   }
 }
@@ -763,6 +857,25 @@ collect_loop(gc_t* gc){
   int scan_ptr_count = 0;
   do{
     done = 1;
+    { /* scan the pending pairs pages */
+      qupages_t* qu = gc->queues[meta_pair];
+      if(qu){
+        done = 0;
+        gc->queues[meta_pair] = 0;
+        do{
+          ikp p = qu->p;
+          ikp q = qu->q;
+          while(p < q){
+            ref(p,0) = add_object(gc, ref(p,0));
+            p += (2*wordsize);
+          }
+          qupages_t* next = qu->next;
+          ik_free(qu, sizeof(qupages_t));
+          qu = next;
+        } while(qu);
+      }
+    }
+
     { /* scan the pending pointer pages */
       qupages_t* qu = gc->queues[meta_ptrs];
       if(qu){
@@ -781,24 +894,6 @@ collect_loop(gc_t* gc){
         } while(qu);
       }
     }
-    { /* scan the pending weak-pointer pages */
-      qupages_t* qu = gc->queues[meta_weak];
-      if(qu){
-        done = 0;
-        gc->queues[meta_weak] = 0;
-        do{
-          ikp p = qu->p;
-          ikp q = qu->q;
-          while(p < q){
-            ref(p,wordsize) = add_object(gc, ref(p,wordsize));
-            p += (2*wordsize);
-          }
-          qupages_t* next = qu->next;
-          ik_free(qu, sizeof(qupages_t));
-          qu = next;
-        } while(qu);
-      }
-    }
     { /* scan the pending code objects */
       qupages_t* codes = gc->queues[meta_code];
       if(codes){
@@ -810,9 +905,7 @@ collect_loop(gc_t* gc){
           while(p < q){
             relocate_new_code(p, gc);
             alloc_code_count--;
-            p += align(disp_code_data +
-                       (int)ref(p, disp_code_code_size) + 
-                       (int)ref(p, disp_code_reloc_size));
+            p += align(disp_code_data + unfix(ref(p, disp_code_code_size))); 
           }
           qupages_t* next = codes->next;
           ik_free(codes, sizeof(qupages_t));
@@ -822,6 +915,23 @@ collect_loop(gc_t* gc){
     }
     {/* see if there are any remaining in the main ptr segment */
       int i;
+      for(i=0; i<=gc->collect_gen; i++){
+        meta_t* meta = &gc->meta[i][meta_pair];
+        ikp p = meta->aq;
+        ikp q = meta->ap;
+        if(p < q){
+          done = 0;
+          do{
+            meta->aq = q;
+            while(p < q){
+              ref(p,0) = add_object(gc, ref(p,0));
+              p += (2*wordsize);
+            }
+            p = meta->aq;
+            q = meta->ap;
+          } while (p < q);
+        }
+      }
       for(i=0; i<=gc->collect_gen; i++){
         meta_t* meta = &gc->meta[i][meta_ptrs];
         ikp p = meta->aq;
@@ -839,24 +949,6 @@ collect_loop(gc_t* gc){
           } while (p < q);
         }
       }
-      for(i=0; i<=gc->collect_gen; i++){
-        meta_t* meta = &gc->meta[i][meta_weak];
-        ikp p = meta->aq;
-        ikp q = meta->ap;
-        if(p < q){
-          done = 0;
-          do{
-            meta->aq = q;
-            while(p < q){
-              ref(p,wordsize) = add_object(gc, ref(p,wordsize));
-              scan_ptr_count += wordsize;
-              p += (2*wordsize);
-            }
-            p = meta->aq;
-            q = meta->ap;
-          } while (p < q);
-        }
-      }
       for(i=0; i<=gc->collect_gen; i++){
         meta_t* meta = &gc->meta[i][meta_code];
         ikp p = meta->aq;
@@ -868,9 +960,7 @@ collect_loop(gc_t* gc){
             do{
               alloc_code_count--;
               relocate_new_code(p, gc);
-              p += align(disp_code_data +
-                         (int)ref(p, disp_code_code_size) + 
-                         (int)ref(p, disp_code_reloc_size));
+              p += align(disp_code_data + unfix(ref(p, disp_code_code_size)));
             } while (p < q);
             p = meta->aq;
             q = meta->ap;
@@ -882,6 +972,15 @@ collect_loop(gc_t* gc){
   } while (! done);
   {
     int i;
+    for(i=0; i<=gc->collect_gen; i++){
+      meta_t* meta = &gc->meta[i][meta_pair];
+      ikp p = meta->ap;
+      ikp q = meta->ep;
+      while(p < q){
+        ref(p, 0) = 0;
+        p += wordsize;
+      }
+    }
     for(i=0; i<=gc->collect_gen; i++){
       meta_t* meta = &gc->meta[i][meta_ptrs];
       ikp p = meta->ap;
@@ -1000,6 +1099,49 @@ scan_dirty_pointers_page(gc_t* gc, int page_idx, int mask){
   dirty_vec[page_idx] = new_d;
 }
 
+static void            
+scan_dirty_code_page(gc_t* gc, int page_idx, unsigned int mask){
+  ikp p = (ikp)(page_idx << pageshift);
+  ikp start = p;
+  ikp q = p + pagesize;
+  unsigned int* segment_vec = gc->segment_vector;
+  unsigned int* dirty_vec = gc->pcb->dirty_vector;
+  //unsigned int d = dirty_vec[page_idx];
+  unsigned int t = segment_vec[page_idx];
+  //unsigned int masked_d = d & mask;
+  unsigned int new_d = 0;
+  while(p < q){
+    if(ref(p, 0) != code_tag){
+      p = q;
+    } 
+    else {
+      int j = ((int)p - (int)start) / cardsize;
+      int code_size = unfix(ref(p, disp_code_code_size));
+      relocate_new_code(p, gc);
+      segment_vec = gc->segment_vector;
+      ikp rvec = ref(p, disp_code_reloc_vector);
+      int len = (int)ref(rvec, off_vector_length);
+      assert(len >= 0);
+      int i;
+      unsigned int code_d = segment_vec[page_index(rvec)];
+      for(i=0; i<len; i+=wordsize){
+        ikp r = ref(rvec, i+off_vector_data);
+        if(is_fixnum(r) || (tagof(r) == immediate_tag)){
+          /* do nothing */
+        } else {
+          r = add_object(gc, r);
+          segment_vec = gc->segment_vector;
+          code_d = code_d | segment_vec[page_index(r)];
+        }
+      }
+      new_d = new_d | (code_d<<(j*meta_dirty_shift));
+      p += align(code_size + disp_code_data);
+    }
+  }
+  dirty_vec = gc->pcb->dirty_vector;
+  new_d = new_d & cleanup_mask[t & gen_mask];
+  dirty_vec[page_idx] = new_d;
+}
 
 /* scanning dirty weak pointers should add the cdrs of the pairs
  * but leave the cars unmodified.  The dirty mask is also kept 
@@ -1057,13 +1199,21 @@ scan_dirty_pages(gc_t* gc){
           scan_dirty_pointers_page(gc, i, mask);
           dirty_vec = pcb->dirty_vector;
           segment_vec = pcb->segment_vector;
-        } else if (type == weak_pairs_type){
+        }
+        else if (type == weak_pairs_type){
           if((t & gen_mask) > collect_gen){
             scan_dirty_weak_pointers_page(gc, i, mask);
             dirty_vec = pcb->dirty_vector;
             segment_vec = pcb->segment_vector;
           }
         }
+        else if (type == code_type){
+          if((t & gen_mask) > collect_gen){
+            scan_dirty_code_page(gc, i, mask);
+            dirty_vec = pcb->dirty_vector;
+            segment_vec = pcb->segment_vector;
+          }
+        }
         else if (t & scannable_mask) {
           fprintf(stderr, "BUG: unhandled scan of type 0x%08x\n", t);
           exit(-1);
@@ -1142,6 +1292,50 @@ fix_new_pages(gc_t* gc){
           d = d | (card_d<<(j*meta_dirty_shift));
         }
         dirty_vec[i] = d & cleanup_mask[page_gen];
+      } 
+      else if((t & type_mask) == code_type){
+        /* FIXME: scan codes */
+        ikp page_base = (ikp)(i << pageshift);
+        ikp p = page_base;
+        ikp q = p + pagesize;
+        int err = mprotect(page_base, pagesize, PROT_READ|PROT_WRITE|PROT_EXEC);
+        if(err){
+          fprintf(stderr, "cannot protect code page: %s\n", strerror(errno));
+          exit(-1);
+        }
+        unsigned int d = 0;
+        while(p < q){
+          if(ref(p, 0) != code_tag){
+            p = q;
+          }
+          else {
+            ikp rvec = ref(p, disp_code_reloc_vector);
+            int size = (int)ref(rvec, off_vector_length);
+            ikp vp = rvec + off_vector_data;
+            ikp vq = vp + size;
+            unsigned int code_d = segment_vec[page_index(rvec)];
+            while(vp < vq){
+              ikp x = ref(vp, 0);
+              if(is_fixnum(x) || (tagof(x) == immediate_tag)){
+                /* do nothing */
+              } else {
+                code_d = code_d || segment_vec[page_index(x)];
+              }
+              vp += wordsize;
+            }
+            code_d = (code_d & meta_dirty_mask) >> meta_dirty_shift;
+            int j = ((int)p - (int)page_base)/cardsize;
+            d = d | (code_d<<(j*meta_dirty_shift));
+            p += align(disp_code_data + unfix(ref(p, disp_code_code_size)));
+          }
+        }
+        dirty_vec[i] = d & cleanup_mask[page_gen];
+      }
+      else {
+        if(t & scannable_mask){
+          fprintf(stderr, "unscanned 0x%08x\n", t);
+          exit(-1);
+        }
       }
     }
     i++;
diff --git a/src/runtime/ikarus-data.h b/src/runtime/ikarus-data.h
index 45fb1d4..19cacc7 100644
--- a/src/runtime/ikarus-data.h
+++ b/src/runtime/ikarus-data.h
@@ -5,21 +5,15 @@
 #define IK_FASL_HEADER_LEN (strlen(IK_FASL_HEADER))
 #define IK_FASL_CODE_HEADER_SIZE 12
 
-#define IK_CODE_PRI_TAG              5
 #define code_pri_tag vector_tag
-#define IK_CODE_SEC_TAG           ((ikp)0x2F)
 #define code_tag                  ((ikp)0x2F)
-#define IK_DISP_CODE_CODE_SIZE       4
 #define disp_code_code_size 4
-#define IK_DISP_CODE_RELOC_SIZE      8
-#define disp_code_reloc_size 8
-#define IK_DISP_CODE_CLOSURE_SIZE   12
-#define disp_code_closure_size 12
-#define IK_DISP_CODE_DATA           16
+#define disp_code_reloc_vector 8
+#define disp_code_freevars 12
 #define disp_code_data 16
 #define off_code_data (disp_code_data - code_pri_tag)
+#define off_code_reloc_vector (disp_code_reloc_vector - code_pri_tag)
 
-#define IK_OFF_CODE_DATA (IK_DISP_CODE_DATA - IK_CODE_PRI_TAG)
 
 #define IK_ALIGN_SHIFT 3
 #define align_shift 3
@@ -150,13 +144,15 @@
 #define disp_rtd_length   8
 #define disp_rtd_fields  12
 #define disp_rtd_printer 16
-#define rtd_size 20
+#define disp_rtd_symbol  20
+#define rtd_size 24
 
 #define off_rtd_rtd     (disp_rtd_rtd     - rtd_tag) 
 #define off_rtd_name    (disp_rtd_name    - rtd_tag) 
 #define off_rtd_length  (disp_rtd_length  - rtd_tag) 
 #define off_rtd_fields  (disp_rtd_fields  - rtd_tag) 
 #define off_rtd_printer (disp_rtd_printer - rtd_tag) 
+#define off_rtd_symbol  (disp_rtd_symbol  - rtd_tag) 
 
 #define continuation_tag      ((ikp)0x1F)
 #define disp_continuation_top   4
diff --git a/src/runtime/ikarus-exec.c b/src/runtime/ikarus-exec.c
index 21eda6c..00e9651 100644
--- a/src/runtime/ikarus-exec.c
+++ b/src/runtime/ikarus-exec.c
@@ -13,7 +13,7 @@ typedef struct {
 
 
 ikp ik_exec_code(ikpcb* pcb, ikp code_ptr){
-  ikp argc = ik_asm_enter(pcb, code_ptr+IK_DISP_CODE_DATA-IK_CODE_PRI_TAG,0);
+  ikp argc = ik_asm_enter(pcb, code_ptr+off_code_data,0);
   ikp next_k =  pcb->next_k;
   while(next_k){
     cont* k = (cont*)(next_k - vector_tag);
diff --git a/src/runtime/ikarus-fasl.c b/src/runtime/ikarus-fasl.c
index 42759e7..db03c46 100644
--- a/src/runtime/ikarus-fasl.c
+++ b/src/runtime/ikarus-fasl.c
@@ -15,6 +15,7 @@
 
 
 typedef struct {
+  char* membase;
   char* memp;
   char* memq;
   ikp* marks;
@@ -56,6 +57,7 @@ void ik_fasl_load(ikpcb* pcb, char* fasl_file){
   }
 
   fasl_port p;
+  p.membase = mem;
   p.memp = mem;
   p.memq = mem + filesize;
   p.marks = NULL;
@@ -65,7 +67,7 @@ void ik_fasl_load(ikpcb* pcb, char* fasl_file){
   while(p.memp < p.memq){
     ikp v = ik_fasl_read(pcb, &p);
     if(p.marks){
-      bzero(p.marks, p.marks_size);
+      bzero(p.marks, p.marks_size * sizeof(ikp*));
     }
     ikp val = ik_exec_code(pcb, v);
     if(val != void_object){
@@ -93,18 +95,74 @@ void ik_fasl_load(ikpcb* pcb, char* fasl_file){
 
 
 static ikp 
-ik_make_code(int code_size, int reloc_size, ikp closure_size, ikpcb* pcb){
-  int required_memory = 
-    align_to_next_page(code_size + reloc_size + disp_code_data);
+alloc_code(int size, ikpcb* pcb){
+  int required_memory = align_to_next_page(size);
   ikp mem = ik_mmap_code(required_memory, 0, pcb);
-  ref(mem, 0) = code_tag;
-  ref(mem, disp_code_code_size) = (ikp) code_size;
-  ref(mem, disp_code_reloc_size) = (ikp) reloc_size;
-  ref(mem, disp_code_closure_size) = closure_size;
-  ref(mem,disp_code_data+code_size+reloc_size) = 0;
-  return (ikp)(mem+vector_tag);
+  return (ikp)mem;
 }
 
+
+void
+ik_relocate_code(ikp code){
+  ikp vec = ref(code, disp_code_reloc_vector);
+  ikp size = ref(vec, off_vector_length);
+  ikp data = code + disp_code_data;
+  ikp p = vec + off_vector_data;
+  ikp q = p + (int)size;
+  while(p < q){
+    int r = unfix(ref(p, 0));
+    if(r == 0){
+      fprintf(stderr, "unset reloc!\n");
+      exit(-1);
+    }
+    int tag = r & 3;
+    int code_off = r >> 2;
+//    fprintf(stderr, "data=0x%08x, off=0x%08x, data+off=0x%08x, r=0x%08x\n",
+//        (int)data, code_off, (int)data+code_off, r);
+//    fprintf(stderr, "setting 0x%08x from r=0x%08x\n", (int)(data+code_off), r);
+    if(tag == 0){
+      /* vanilla object */
+      ref(data, code_off) = ref(p, wordsize);
+      p += (2*wordsize);
+    } 
+    else if(tag == 2){
+      /* displaced object */
+      int obj_off = unfix(ref(p, wordsize));
+      ikp obj = ref(p, 2*wordsize);
+      ref(data, code_off) = obj + obj_off;
+      p += (3*wordsize);
+    }
+    else if(tag == 3){
+      /* jump label */
+      int obj_off = unfix(ref(p, wordsize));
+      ikp obj = ref(p, 2*wordsize);
+      ikp displaced_object = obj + obj_off;
+      ikp next_word = data + code_off + wordsize;
+      ikp relative_distance = displaced_object - (int)next_word;
+      ref(next_word, -wordsize) = relative_distance;
+      p += (3*wordsize);
+    }
+    else if(tag == 1){
+      /* foreign object */
+      ikp str = ref(p, wordsize);
+      char* name = string_data(str);
+      void* sym = dlsym(NULL, name);
+      char* err = dlerror();
+      if(err){
+        fprintf(stderr, "failed to find foreign name %s: %s\n", name, err);
+        exit(-1);
+      }
+      ref(data,code_off) = sym;
+      p += (2*wordsize);
+    }
+    else {
+      fprintf(stderr, "invalid reloc 0x%08x (tag=%d)\n", r, tag);
+      exit(-1);
+    }
+  }
+}
+
+
 static char fasl_read_byte(fasl_port* p){
   if(p->memp < p->memq){
     char c = *(p->memp);
@@ -151,7 +209,10 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
     }
     if(idx < p->marks_size){
       if(p->marks[idx] != 0){
-        fprintf(stderr, "mark %d already set\n", idx);
+        fprintf(stderr, "mark %d already set (fileoff=%d)\n", 
+            idx,
+            (int)p->memp - (int)p->membase - 6);
+        ik_print(p->marks[idx]);
         exit(-1);
       }
     } 
@@ -168,7 +229,26 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
       }
     }
   }
+  if(c == 'x'){
+    int code_size;
+    ikp freevars;
+    fasl_read_buf(p, &code_size, sizeof(int));
+    fasl_read_buf(p, &freevars, sizeof(ikp));
+    ikp code = alloc_code(align(code_size+disp_code_data), pcb);
+    ref(code, 0) = code_tag;
+    ref(code, disp_code_code_size) = fix(code_size);
+    ref(code, disp_code_freevars) = freevars;
+    fasl_read_buf(p, code+disp_code_data, code_size);
+    if(put_mark_index){
+      p->marks[put_mark_index] = code+vector_tag;
+    }
+    ref(code, disp_code_reloc_vector) = do_read(pcb, p);
+    ik_relocate_code(code);
+    return code+vector_tag;
+  }
   if(c == 'X'){
+    assert(0);
+#if 0
     code_header ch;
     fasl_read_buf(p, &ch, sizeof(ch));
     ikp code = ik_make_code(ch.code_size, ch.reloc_size, ch.closure_size, pcb);
@@ -185,8 +265,8 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
         int offset;
         fasl_read_buf(p, &offset, sizeof(int));
         ikp object = do_read(pcb, p);
-        REF(code_data,offset) = object;
-        REF(reloc_table, i) = (ikp)(offset << 2);
+        ref(code_data,offset) = object;
+        ref(reloc_table, i) = (ikp)(offset << 2);
         i += wordsize;
       }
       else if(t == 'F'){ /* foreign call */
@@ -211,9 +291,9 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
         fasl_read_buf(p, &code_offset, sizeof(int));
         fasl_read_buf(p, &object_offset, sizeof(int));
         ikp object = do_read(pcb, p);
-        REF(reloc_table, i) = (ikp)((code_offset << 2) | 1);
-        REF(reloc_table, i+wordsize) = (ikp)object_offset;
-        REF(code_data, code_offset) = object + object_offset;
+        ref(reloc_table, i) = (ikp)((code_offset << 2) | 1);
+        ref(reloc_table, i+wordsize) = (ikp)object_offset;
+        ref(code_data, code_offset) = object + object_offset;
         i += (2*wordsize);
       }
       else if(t == 'J'){ /* jump reloc */
@@ -222,11 +302,11 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
         fasl_read_buf(p, &code_offset, sizeof(int));
         fasl_read_buf(p, &object_offset, sizeof(int));
         ikp object = do_read(pcb, p);
-        REF(reloc_table, i) = (ikp)((code_offset << 2) | 2);
-        REF(reloc_table, i+wordsize) = (ikp)object_offset;
+        ref(reloc_table, i) = (ikp)((code_offset << 2) | 2);
+        ref(reloc_table, i+wordsize) = (ikp)object_offset;
         ikp next_word = code_data + code_offset + wordsize;
         ikp displaced_object = object + object_offset;
-        REF(next_word, -wordsize) = displaced_object - (int) next_word;
+        ref(next_word, -wordsize) = displaced_object - (int) next_word;
         i += (2*wordsize);
       }
       else {
@@ -236,6 +316,7 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
     }
     assert(i==ch.reloc_size);
     return code;
+#endif
   }
   else if(c == 'P'){
     ikp pair = ik_alloc(pcb, pair_size) + pair_tag;
@@ -302,6 +383,54 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
     char x = fasl_read_byte(p);
     return byte_to_scheme_char(x);
   }
+  else if(c == 'G'){ /* G is for gensym */
+    ikp pretty = do_read(pcb, p);
+    ikp unique = do_read(pcb, p);
+    ikp sym = ik_alloc(pcb, align(symbol_size)) + symbol_tag;
+    ref(sym, off_symbol_string) = pretty;
+    ref(sym, off_symbol_ustring) = unique;
+    ref(sym, off_symbol_value) = unbound_object;
+    ref(sym, off_symbol_system_value) = unbound_object;
+    ref(sym, off_symbol_plist) = null_object;
+    ref(sym, off_symbol_system_plist) = null_object;
+    if(put_mark_index){
+      p->marks[put_mark_index] = sym;
+    }
+    return sym;
+  }
+  else if(c == 'R'){ /* R is for RTD */
+    ikp name = do_read(pcb, p);
+    ikp symb = do_read(pcb, p);
+    int i, n;
+    fasl_read_buf(p, &n, sizeof(int));
+    ikp fields;
+    if(n == 0){
+      fields = null_object;
+    } else {
+      fields = ik_alloc(pcb, n * align(pair_size)) + pair_tag;
+      ikp ptr = fields;
+      for(i=0; i<n; i++){
+        ref(ptr, off_car) = do_read(pcb, p);
+        ref(ptr, off_cdr) = ptr + align(pair_size);
+        ptr += align(pair_size);
+      }
+      ptr -= pair_size;
+      ref(ptr, off_cdr) = null_object;
+    }
+    ikp rtd = ik_alloc(pcb, align(rtd_size)) + vector_tag;
+    ikp base_sym = ik_cstring_to_symbol("$base-rtd", pcb);
+    ikp base_rtd = ref(base_sym, off_symbol_system_value);
+    ref(rtd, off_rtd_rtd) = base_rtd;
+    ref(rtd, off_rtd_name) = name;
+    ref(rtd, off_rtd_length) = fix(n);
+    ref(rtd, off_rtd_fields) = fields;
+    ref(rtd, off_rtd_printer) = false_object;
+    ref(rtd, off_rtd_symbol) = symb;
+    if(put_mark_index){
+      p->marks[put_mark_index] = rtd;
+    }
+    return rtd;
+  }
   else if(c == '<'){
     int idx;
     fasl_read_buf(p, &idx, sizeof(int));
@@ -322,7 +451,10 @@ static ikp do_read(ikpcb* pcb, fasl_port* p){
     }
   }
   else {
-    fprintf(stderr, "invalid type '%c' found in fasl file\n", c);
+    fprintf(stderr, 
+        "invalid type '%c' (0x%02x) found in fasl file at byte 0x%08x\n", 
+        c, c,
+        (int) p->memp - (int) p->membase - 1);
     exit(-1);
   }
 }
diff --git a/src/runtime/ikarus-hash-tables.c b/src/runtime/ikarus-hash-tables.c
deleted file mode 100644
index bed016c..0000000
--- a/src/runtime/ikarus-hash-tables.c
+++ /dev/null
@@ -1,71 +0,0 @@
-
-#include "ikarus.h"
-#include <strings.h>
-
-/* from http://www.concentric.net/~Ttwang/tech/inthash.htm */
-
-ikp 
-ik_get_hash_table(ikp ht, ikp k, ikp def, ikpcb* pcb){
-  ikp size = ref(ht, off_htable_size);
-  if(size == 0){
-    return def;
-  }
-  ikbucket** table = (ikbucket**) ref(ht, off_htable_mem);
-  int idx = inthash((int)k) & (unfix(size)-1);
-  ikbucket* p = table[idx];
-  while(p){
-    if(p->key == k){
-      return p->val;
-    } else {
-      p = p->next;
-    }
-  }
-  return def;
-}
-
-int hash_table_count = 0;
-
-static void
-initialize_hash_table(ikp ht, ikpcb* pcb){
-  hash_table_count++;
-  ikp mem = ik_mmap(pagesize);
-  bzero(mem, pagesize);
-  ref(ht, off_htable_size)  = (ikp) pagesize;
-  ref(ht, off_htable_count) = 0;
-  ref(ht, off_htable_mem)   = mem;
-  ikhashtables* p = ik_malloc(sizeof(ikhashtables));
-  p->ht = ht;
-  p->next = pcb->hash_tables;
-  pcb->hash_tables = p;
-}
-
-
-ikp 
-ik_put_hash_table(ikp ht, ikp k, ikp v, ikpcb* pcb){
-  ikp size = ref(ht, off_htable_size);
-  if(size == 0){
-    initialize_hash_table(ht, pcb);
-    size = ref(ht, off_htable_size);
-  }
-  ikbucket** table = (ikbucket**) ref(ht, off_htable_mem);
-  int idx = inthash((int)k) & (unfix(size)-1);
-  ikbucket* bucket = table[idx];
-  ikbucket* p = bucket;
-  while(p){
-    if(p->key == k){
-      p->val = v;
-      return void_object;
-    } else {
-      p = p->next;
-    }
-  }
-  p = ik_malloc(sizeof(ikbucket));
-  p->key = k;
-  p->val = v;
-  p->next = bucket;
-  table[idx] = p;
-  ref(ht, off_htable_count) = 
-    fix(unfix(ref(ht, off_htable_count)) + 1);
-  return void_object;
-}
-
diff --git a/src/runtime/ikarus-main.c b/src/runtime/ikarus-main.c
index d5f6f7e..8dc1116 100644
--- a/src/runtime/ikarus-main.c
+++ b/src/runtime/ikarus-main.c
@@ -21,6 +21,12 @@ int main(int argc, char** argv){
     char* fasl_file = argv[i];
     ik_fasl_load(pcb, fasl_file);
   }
+  fprintf(stderr, "collect time: %d.%03d utime, %d.%03d stime (%d collections)\n", 
+   pcb->collect_utime.tv_sec, 
+   pcb->collect_utime.tv_usec/1000, 
+   pcb->collect_stime.tv_sec, 
+   pcb->collect_stime.tv_usec/1000,
+   pcb->collection_id );
   ik_delete_pcb(pcb);
   return 0;
 }
diff --git a/src/runtime/ikarus-runtime.c b/src/runtime/ikarus-runtime.c
index 7582bc3..f615417 100644
--- a/src/runtime/ikarus-runtime.c
+++ b/src/runtime/ikarus-runtime.c
@@ -1,4 +1,5 @@
 #include "ikarus.h"
+#include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -106,7 +107,16 @@ ik_mmap_data(int size, int gen, ikpcb* pcb){
 
 void* 
 ik_mmap_code(int size, int gen, ikpcb* pcb){
-  return ik_mmap_typed(size, code_mt | gen, pcb);
+  ikp p = ik_mmap_typed(size, code_mt | gen, pcb);
+  if(size > pagesize){
+    set_segment_type(p+pagesize, size-pagesize, data_mt|gen, pcb);
+  }
+  int err = mprotect(p, size, PROT_READ | PROT_WRITE | PROT_EXEC);
+  if(err){
+    fprintf(stderr, "cannot mprotect code: %s\n", strerror(errno));
+    exit(-1);
+  }
+  return p;
 }
 
 
@@ -200,27 +210,21 @@ ikp ik_mmap_protected(int size){
 
 
 ikpcb* ik_make_pcb(){
-  ikpcb* pcb = malloc(sizeof(ikpcb));
-  if(pcb == NULL){
-    fprintf(stderr, "Failed to allocate pcb\n");
-    exit(-1);
-  }
+  ikpcb* pcb = ik_malloc(sizeof(ikpcb));
   bzero(pcb, sizeof(ikpcb));
   #define HEAPSIZE (1024 * 4096)
   #define STAKSIZE (1024 * 4096)
+  //#define STAKSIZE (256 * 4096)
   pcb->heap_base = ik_mmap_protected(HEAPSIZE);
   pcb->heap_size = HEAPSIZE;
   pcb->allocation_pointer = pcb->heap_base;
   pcb->allocation_redline = pcb->heap_base + HEAPSIZE - 2 * 4096;
 
-  pcb->stack_base = ik_mmap_protected(STAKSIZE);
+  pcb->stack_base = ik_mmap(STAKSIZE);
   pcb->stack_size = STAKSIZE;
   pcb->frame_pointer = pcb->stack_base + pcb->stack_size;
   pcb->frame_base = pcb->frame_pointer;
   pcb->frame_redline = pcb->stack_base + 2 * 4096;
-  ikdl* codes = &(pcb->codes);
-  codes->next = codes;
-  codes->prev = codes;
 
   {
     /* compute extent of heap and stack */
@@ -251,8 +255,8 @@ ikpcb* ik_make_pcb(){
         pcb->heap_size+2*pagesize, 
         mainheap_mt,
         pcb);
-    set_segment_type(pcb->stack_base-pagesize, 
-        pcb->stack_size+2*pagesize, 
+    set_segment_type(pcb->stack_base, 
+        pcb->stack_size, 
         mainstack_mt,
         pcb);
   }
@@ -265,6 +269,7 @@ ikpcb* ik_make_pcb(){
     ref(r, off_rtd_name) = 0;
     ref(r, off_rtd_fields) = 0;
     ref(r, off_rtd_printer) = 0;
+    ref(r, off_rtd_symbol) = 0;
     ref(s, off_symbol_system_value) = r;
     ref(s, off_symbol_value) = r;
   }
@@ -272,8 +277,22 @@ ikpcb* ik_make_pcb(){
 }
 
 void ik_delete_pcb(ikpcb* pcb){
-  assert(0);
-  free(pcb);
+  unsigned char* base = pcb->memory_base;
+  unsigned char* end = pcb->memory_end;
+  unsigned int* segment_vec = pcb->segment_vector;
+  int i = page_index(base);
+  int j = page_index(end);
+  while(i < j){
+    unsigned int t = segment_vec[i];
+    if(t != hole_mt){
+      ik_munmap((ikp)(i<<pageshift), pagesize);
+    }
+    i++;
+  }
+  int vecsize = (segment_index(end) - segment_index(base)) * pagesize;
+  ik_munmap(pcb->dirty_vector_base, vecsize);
+  ik_munmap(pcb->segment_vector_base, vecsize);
+  ik_free(pcb, sizeof(ikpcb));
 }
 
 
@@ -289,6 +308,8 @@ ik_alloc(ikpcb* pcb, int size){
   } 
   else {
     fprintf(stderr, "EXT\n");
+    assert(0);
+#if 0
     if(ap){
       ikpages* p = ik_malloc(sizeof(ikpages));
       p->base = pcb->heap_base;
@@ -306,6 +327,7 @@ ik_alloc(ikpcb* pcb, int size){
     nap = ap + size;
     pcb->allocation_pointer = nap;
     return ap;
+#endif
   }
 }
 
@@ -319,11 +341,33 @@ void ik_error(ikp args){
 }
 
 
-void ik_stack_overflow(){
-  fprintf(stderr, "entered ik_stack_overflow\n");
-  exit(-1);
+void ik_stack_overflow(ikpcb* pcb){
+  fprintf(stderr, "entered ik_stack_overflow pcb=0x%08x\n", (int)pcb);
+
+  set_segment_type(pcb->stack_base, pcb->stack_size, data_mt, pcb);
+  
+  ikp frame_base = pcb->frame_base;
+  ikp underflow_handler = ref(frame_base, -wordsize);
+  fprintf(stderr, "underflow_handler = 0x%08x\n", (int)underflow_handler);
+  /* capture continuation and set it as next_k */
+  ikp k = ik_alloc(pcb, align(continuation_size)) + vector_tag;
+  ref(k, -vector_tag) = continuation_tag;
+  ref(k, off_continuation_top) = pcb->frame_pointer;
+  ref(k, off_continuation_size) = 
+    pcb->frame_base - (int)pcb->frame_pointer - wordsize;
+  ref(k, off_continuation_next) = pcb->next_k;
+  pcb->next_k = k;
+
+  pcb->stack_base = ik_mmap_typed(STAKSIZE, mainstack_mt, pcb);
+  pcb->stack_size = STAKSIZE;
+  pcb->frame_base = pcb->stack_base + pcb->stack_size;
+  pcb->frame_pointer = pcb->frame_base - wordsize;
+  pcb->frame_redline = pcb->stack_base + 2 * 4096;
+  ref(pcb->frame_pointer, 0) = underflow_handler;
+  return;
 }
 
+/*
 char* ik_uuid(char* str){
   assert((36 << fx_shift) == (int) ref(str, disp_string_length - string_tag));
   uuid_t u;
@@ -332,6 +376,33 @@ char* ik_uuid(char* str){
   uuid_unparse_upper(u, str + disp_string_data - string_tag);
   return str;
 }
+*/
+
+
+static const char* uuid_chars = 
+"!$%&/0123456789<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+static int uuid_strlen = 1;
+
+ikp ik_uuid(ikp str){
+  static int fd = -1;
+  if(fd == -1){
+    fd = open("/dev/urandom", O_RDONLY);
+    if(fd == -1){
+      return false_object;
+    }
+    uuid_strlen = strlen(uuid_chars);
+  }
+  int n = unfix(ref(str, off_string_length));
+  unsigned char* data = str+off_string_data;
+  read(fd, data, n);
+  unsigned char* p = data;
+  unsigned char* q = data + n;
+  while(p < q){
+    *p = uuid_chars[*p % uuid_strlen];
+    p++;
+  }
+  return str;
+}
 
 
 ikp ik_read(ikp fdptr, ikp bufptr, ikp lenptr){
@@ -376,7 +447,7 @@ ikp ik_open_file(ikp str, ikp flagptr){
   int f = unfix(flagptr);
   char* path = (char*)(str + disp_string_data - string_tag);
   if(f == 0){
-    flags = O_WRONLY;
+    flags = O_WRONLY | O_CREAT;
   } else if(f == 1){
     flags = O_WRONLY | O_APPEND;
   } else if(f == 2){
@@ -473,3 +544,118 @@ ik_dump_dirty_vector(ikpcb* pcb){
   return void_object;
 }
 
+ikp 
+ikrt_make_code(ikp codesizeptr, ikp freevars, ikp rvec, ikpcb* pcb){
+  int code_size = unfix(codesizeptr);
+  int memreq = align_to_next_page(code_size + disp_code_data);
+  ikp mem = ik_mmap_code(memreq, 0, pcb);
+  ref(mem, 0) = code_tag;
+  ref(mem, disp_code_code_size) = codesizeptr;
+  ref(mem, disp_code_freevars) = freevars;
+  ref(mem, disp_code_reloc_vector) = rvec;
+  ik_relocate_code(mem);
+  return mem+vector_tag;
+}
+
+ikp
+ikrt_set_code_reloc_vector(ikp code, ikp vec, ikpcb* pcb){
+  ref(code, off_code_reloc_vector) = vec;
+  ik_relocate_code(code-vector_tag);
+  pcb->dirty_vector[page_index(code)] = -1;
+  return void_object;
+}
+
+ikp
+ikrt_strftime(ikp outstr, ikp fmtstr){
+  time_t t;
+  struct tm* tmp;
+  t = time(NULL);
+  tmp = localtime(&t);
+  if(tmp == NULL){
+    fprintf(stderr, "Error in time: %s\n", strerror(errno));
+  }
+  int rv = 
+    strftime((char*)outstr+off_string_data,
+             unfix(ref(outstr, off_string_length)) + 1,
+             (char*)fmtstr+off_string_data,
+             tmp);
+  if(rv == 0){
+    fprintf(stderr, "Error in strftime: %s\n", strerror(errno));
+  }
+  return fix(rv);
+}
+
+ikp
+ikrt_close_file(ikp fd, ikpcb* pcb){
+  int err = close(unfix(fd));
+  if(err == -1){
+    return false_object;
+  } else {
+    return true_object;
+  }
+}
+
+ikp
+ikrt_read(ikp fd, ikp buff, ikpcb* pcb){
+  int bytes = read(unfix(fd), string_data(buff), unfix(ref(buff, off_string_length)));
+  if(bytes == -1){
+    return false_object;
+  } else {
+    return fix(bytes);
+  }
+}
+
+ikp
+ikrt_open_input_file(ikp fname, ikpcb* pcb){
+  int fd = open(string_data(fname), O_RDONLY);
+  if(fd == -1){
+    return false_object;
+  } else {
+    return fix(fd);
+  }
+}
+
+ikp
+ikrt_open_output_file(ikp fname, ikp flagptr, ikpcb* pcb){
+  /* [(error)    0] */ 
+  /* [(replace)  1] */
+  /* [(truncate) 2] */
+  /* [(append)   3] */
+  int flags;
+  int f = unfix(flagptr);
+  if(f == 0){
+    flags = O_WRONLY;
+  } else if(f == 1){
+    unlink(string_data(fname));
+    flags = O_WRONLY | O_CREAT;
+  } else if(f == 2){
+    flags = O_WRONLY | O_TRUNC;
+  } else if(f == 3){
+    flags = O_WRONLY | O_APPEND;
+  } else {
+    fprintf(stderr, "Error in S_open_file: invalid mode 0x%08x\n", 
+                  (int)flagptr);
+    exit(-10);
+  }
+  int fd = open(string_data(fname), flags,
+                S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+  if(fd == -1){
+    fprintf(stderr, "openfile failed!\n");
+    return false_object;
+  } else {
+    return fix(fd);
+  }
+}
+
+
+ikp
+ikrt_write_file(ikp fd, ikp buff, ikp idx, ikpcb* pcb){
+  int bytes = write(unfix(fd), string_data(buff), unfix(idx));
+  return fix(bytes);
+}
+
+ikp 
+ikrt_write_char(){
+  fprintf(stderr, "ikrt_write_char\n");
+  return void_object;
+}
diff --git a/src/runtime/ikarus-symbol-table.c b/src/runtime/ikarus-symbol-table.c
index 06be03e..acdf73f 100644
--- a/src/runtime/ikarus-symbol-table.c
+++ b/src/runtime/ikarus-symbol-table.c
@@ -2,20 +2,19 @@
 #include "ikarus.h"
 #include <strings.h>
 #include <string.h>
+#include <stdlib.h>
 
-static ikoblist*
+static ikp
 initialize_symbol_table(ikpcb* pcb){
   #define NUM_OF_BUCKETS 4096 /* power of 2 */
-  ikoblist* st = ik_malloc(sizeof(ikoblist));
-  st->number_of_buckets = NUM_OF_BUCKETS;
-  int size = NUM_OF_BUCKETS * sizeof(ikbucket*);
-  st->buckets = ik_mmap(size);
-  bzero(st->buckets, size);
+  int size = align_to_next_page(disp_vector_data + NUM_OF_BUCKETS * wordsize);
+  ikp st = ik_mmap_ptr(size, 0, pcb) + vector_tag;
+  bzero(st-vector_tag, size);
+  ref(st, off_vector_length) = fix(NUM_OF_BUCKETS);
   pcb->oblist = st;
   return st;
 }
 
-
 static int 
 compute_hash(ikp str){
   int len = unfix(ref(str, off_string_length));
@@ -56,51 +55,33 @@ static ikp ik_make_symbol(ikp str, ikpcb* pcb){
 }
 
 ikp ik_oblist(ikpcb* pcb){
-  ikoblist* st = pcb->oblist;
-  int n = st->number_of_buckets;
-  ikbucket** bs = st->buckets;
-  ikp ac = null_object;
-  int i;
-  for(i=0; i<n; i++){
-    ikbucket* b = bs[i];
-    while(b){
-      ikp p = ik_alloc(pcb, pair_size) + pair_tag;
-      ref(p, off_car) = b->val;
-      ref(p, off_cdr) = ac;
-      ac = p;
-      b = b->next;
-    }
-  }
-  return ac;
+  fprintf(stderr, "oblist dead!\n");
+  exit(-1);
 }
 
 ikp ik_intern_string(ikp str, ikpcb* pcb){
-  //fprintf(stderr, "0x%08x: intern %s => ", (int)pcb, string_data(str));
-  ikoblist* st = pcb->oblist;
+  ikp st = pcb->oblist;
   if(st == 0){
     st = initialize_symbol_table(pcb);
   }
   int h = compute_hash(str);
-  int idx = h & (st->number_of_buckets - 1);
-  ikbucket* b = st->buckets[idx];
+  int idx = h & (unfix(ref(st, off_vector_length)) - 1);
+  ikp bckt = ref(st, off_vector_data + idx*wordsize);
+  ikp b = bckt;
   while(b){
-//    if(b->key == (ikp) h){
-      ikp sym = b->val;
-      ikp sym_str = ref(sym, off_symbol_string);
-      if(strings_eqp(sym_str, str)){
-        //fprintf(stderr, "SAME %s\n", string_data(str));
-        return sym;
-      }
-//    }
-    b = b->next;
+    ikp sym = ref(b, off_car);
+    ikp sym_str = ref(sym, off_symbol_string);
+    if(strings_eqp(sym_str, str)){
+      return sym;
+    }
+    b = ref(b, off_cdr);
   }
   ikp sym = ik_make_symbol(str, pcb);
-  b = ik_malloc(sizeof(ikbucket));
-  b->key = (ikp)h;
-  b->val = sym;
-  b->next = st->buckets[idx];
-  st->buckets[idx] = b;
-  //fprintf(stderr, "NEW\n");
+  b = ik_alloc(pcb, pair_size) + pair_tag;
+  ref(b, off_car) = sym;
+  ref(b, off_cdr) = bckt;
+  ref(st, off_vector_data + idx*wordsize) = b;
+  pcb->dirty_vector[page_index(st+off_vector_data+idx*wordsize)] = -1;
   return sym;
 }
 
diff --git a/src/runtime/ikarus.h b/src/runtime/ikarus.h
index 430c7e8..250a6fe 100644
--- a/src/runtime/ikarus.h
+++ b/src/runtime/ikarus.h
@@ -3,6 +3,7 @@
 #define IKARUS_H
 
 #include <stdio.h>
+#include <sys/resource.h>
 
 extern int total_allocated_pages;
 extern int total_malloced;
@@ -72,21 +73,6 @@ typedef struct ikdl{ /* double-link */
   struct ikdl* next;
 } ikdl;
 
-typedef struct ikhashtables{
-  ikp ht;
-  struct ikhashtables* next;
-} ikhashtables;
-
-typedef struct ikbucket{
-  ikp key;
-  ikp val;
-  struct ikbucket* next;
-} ikbucket;
-
-typedef struct{
-  int number_of_buckets;
-  ikbucket** buckets;
-} ikoblist;
 
 typedef struct {
   /* the first locations may be accessed by some     */
@@ -109,15 +95,15 @@ typedef struct {
   int   heap_size;
   ikp   stack_base;
   int   stack_size;
-  ikpages* heap_pages;
-  ikdl codes;
-  ikhashtables* hash_tables;
-  ikoblist*   oblist;
+  ikp   oblist;
   unsigned int* dirty_vector_base;
   unsigned int* segment_vector_base;
   unsigned char* memory_base;
   unsigned char* memory_end;
   int collection_id;
+  struct timeval collect_utime;
+  struct timeval collect_stime;
+  
 } ikpcb;
 
 
@@ -135,8 +121,10 @@ void ik_munmap(void*, int);
 void ik_munmap_from_segment(unsigned char*, int, ikpcb*);
 ikpcb* ik_make_pcb();
 void ik_delete_pcb(ikpcb*);
+void ik_free_symbol_table(ikpcb* pcb);
 
 void ik_fasl_load(ikpcb* pcb, char* filename);
+void ik_relocate_code(ikp);
 
 ikp ik_exec_code(ikpcb* pcb, ikp code_ptr);
 void ik_print(ikp x);
diff --git a/src/set-operations.ss b/src/set-operations.ss
index 7207e6c..e598fc3 100644
--- a/src/set-operations.ss
+++ b/src/set-operations.ss
@@ -1,11 +1,11 @@
 
-(define list*
-  (lambda (fst . rest)
-    (let f ([fst fst] [rest rest])
-      (cond
-        [(null? rest) fst]
-        [else 
-         (cons fst (f (car rest) (cdr rest)))]))))
+;; (define list*
+;;   (lambda (fst . rest)
+;;     (let f ([fst fst] [rest rest])
+;;       (cond
+;;         [(null? rest) fst]
+;;         [else 
+;;          (cons fst (f (car rest) (cdr rest)))]))))
 
 (define (remq x ls)
   (cond
diff --git a/src/time-read.ss b/src/time-read.ss
new file mode 100644
index 0000000..7ad60d4
--- /dev/null
+++ b/src/time-read.ss
@@ -0,0 +1,43 @@
+
+(define scheme-library-files
+  '(["libhandlers-6.9.ss"    "libhandlers.fasl"]
+    ["libcontrol-6.1.ss"     "libcontrol.fasl"]
+    ["libcollect-6.1.ss"     "libcollect.fasl"]
+    ["librecord-6.4.ss"      "librecord.fasl"]
+    ["libcxr-6.0.ss"         "libcxr.fasl"]
+    ["libcore-6.9.ss"        "libcore.fasl"]
+    ["libio-6.9.ss"          "libio.fasl"]
+    ["libwriter-6.2.ss"      "libwriter.fasl"]
+    ["libtokenizer-6.1.ss"   "libtokenizer.fasl"]
+    ["libassembler-6.7.ss"   "libassembler.ss"]
+    ["libintelasm-6.9.ss"    "libintelasm.fasl"]
+    ["libfasl-6.7.ss"        "libfasl.fasl"]
+    ["libcompile-6.7.ss"     "libcompile.fasl"]
+    ["psyntax-7.1-6.9.ss"    "psyntax.fasl"]
+    ["libinterpret-6.5.ss"   "libinterpret.fasl"]
+    ["libcafe-6.1.ss"        "libcafe.fasl"]
+    ["libtrace-6.9.ss"       "libtrace.fasl"]
+    ["libposix-6.0.ss"       "libposix.fasl"]
+    ["libhash-6.2.ss"        "libhash.fasl"]
+    ["libtoplevel-6.9.ss"    "libtoplevel.fasl"]
+    ))
+
+(define (read-file x)
+  (with-input-from-file x
+    (lambda ()
+      (let f ()
+        (unless (eof-object? (read-char)) (f))))))
+
+(define (read-all)
+  (for-each
+    (lambda (x)
+      (read-file (car x)))
+    scheme-library-files))
+
+(define (do-times n f)
+  (unless (fxzero? n)
+    (f)
+    (do-times (fx- n 1) f)))
+
+(do-times 10 read-all)
+
diff --git a/src/unsafe-record.ss b/src/unsafe-record.ss
new file mode 100644
index 0000000..e3f0376
--- /dev/null
+++ b/src/unsafe-record.ss
@@ -0,0 +1,51 @@
+
+(define-syntax $define-record-syntax
+  (lambda (x)
+    (syntax-case x ()
+      [(_ name (field* ...)) 
+       (let* ([namestr (symbol->string (syntax-object->datum #'name))]
+              [fields (syntax-object->datum #'(field* ...))]
+              [fieldstr* (map symbol->string fields)]
+              [rtd (make-record-type namestr fields)])
+         (with-syntax ([constr 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "$make-" namestr)))]
+                       [pred 
+                        (datum->syntax-object #'name
+                          (string->symbol
+                            (string-append "$" namestr "?")))]
+                       [(i ...)
+                        (datum->syntax-object #'name
+                          (let f ([i 0] [f* fieldstr*])
+                            (cond
+                              [(null? f*) '()]
+                              [else (cons i (f (fxadd1 i) (cdr f*)))])))]
+                       [(getters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x)
+                                 (string->symbol 
+                                   (string-append "$" namestr "-" x)))
+                               fieldstr*))]
+                       [(setters ...)
+                        (datum->syntax-object #'name
+                          (map (lambda (x) 
+                                 (string->symbol
+                                   (string-append "$set-" namestr "-" x "!")))
+                               fieldstr*))]
+                       [rtd rtd])
+            #'(begin
+                (define-syntax name (cons '$rtd 'rtd))
+                (define-syntax constr
+                  (syntax-rules ()
+                    [(_ field* ...) ($record 'rtd field* ...)]))
+                (define-syntax pred
+                  (syntax-rules ()
+                    [(_ x) ($record/rtd? x 'rtd)]))
+                (define-syntax getters 
+                  (syntax-rules ()
+                    [(_ x) ($record-ref x i)])) ...
+                (define-syntax setters 
+                  (syntax-rules ()
+                    [(_ x v) ($record-set! x i v)])) ...
+                )))])))
diff --git a/src/xpsyntax.pp b/src/xpsyntax.pp
deleted file mode 100644
index c4041bf..0000000
--- a/src/xpsyntax.pp
+++ /dev/null
@@ -1,55957 +0,0 @@
-((case-lambda
-   [()
-    ((case-lambda
-       [(g0 g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15 g16
-         g17 g18 g19 g20 g21 g22 g23 g24 g25 g26 g27 g28 g29 g30 g31
-         g32 g33 g34 g35 g36 g37 g38 g39 g40 g41 g42 g43 g44 g45 g46
-         g47 g48 g49 g50 g51 g52 g53 g54 g55 g56 g57 g58 g59 g60 g61
-         g62 g63 g64 g65 g66 g67 g68 g69 g70 g71 g72 g73 g74 g75 g76
-         g77 g78 g79 g80 g81 g82 g83 g84 g85 g86 g87 g88 g89 g90 g91
-         g92 g93 g94 g95 g96 g97 g98 g99 g100 g101 g102 g103 g104
-         g105 g106 g107 g108 g109 g110 g111 g112 g113 g114 g115 g116
-         g117 g118 g119 g120 g121 g122 g123 g124 g125 g126 g127 g128
-         g129 g130 g131 g132 g133 g134 g135 g136 g137 g138 g139 g140
-         g141 g142 g143 g144 g145 g146 g147 g148 g149 g150 g151 g152
-         g153 g154 g155 g156 g157 g158 g159 g160 g161 g162 g163 g164
-         g165 g166 g167 g168 g169 g170 g171 g172 g173 g174 g175 g176
-         g177 g178 g179 g180 g181 g182 g183 g184 g185 g186 g187 g188
-         g189 g190 g191 g192 g193 g194 g195 g196 g197 g198 g199 g200)
-        ((case-lambda
-           [(g201 g202 g203 g204 g205 g206 g207 g208 g209 g210 g211
-             g212 g213 g214 g215 g216 g217 g218 g219 g220 g221 g222 g223
-             g224 g225 g226 g227 g228 g229 g230 g231 g232 g233 g234 g235
-             g236 g237 g238 g239 g240 g241 g242 g243 g244 g245 g246 g247
-             g248 g249 g250 g251 g252 g253 g254 g255 g256 g257 g258 g259
-             g260 g261 g262 g263 g264 g265 g266 g267 g268 g269 g270 g271
-             g272 g273 g274 g275 g276 g277 g278 g279 g280 g281 g282 g283
-             g284 g285 g286 g287 g288 g289 g290 g291 g292 g293 g294 g295
-             g296 g297 g298 g299 g300 g301 g302 g303 g304 g305 g306 g307
-             g308 g309 g310 g311 g312 g313 g314 g315 g316 g317 g318 g319
-             g320 g321 g322 g323 g324 g325 g326 g327 g328 g329 g330 g331
-             g332 g333 g334 g335 g336 g337 g338 g339 g340 g341 g342 g343
-             g344 g345 g346 g347 g348 g349 g350 g351 g352 g353 g354 g355
-             g356 g357 g358 g359 g360 g361 g362 g363 g364 g365 g366 g367
-             g368 g369 g370 g371 g372 g373 g374 g375 g376 g377 g378 g379
-             g380 g381 g382 g383 g384 g385 g386 g387 g388 g389 g390 g391
-             g392 g393 g394 g395 g396 g397 g398 g399 g400 g401)
-            (begin
-              (set! g0 g201)
-              (set! g1 g202)
-              (set! g2 g203)
-              (set! g3 g204)
-              (set! g4 g205)
-              (set! g5 g206)
-              (set! g6 g207)
-              (set! g7 g208)
-              (set! g8 g209)
-              (set! g9 g210)
-              (set! g10 g211)
-              (set! g11 g212)
-              (set! g12 g213)
-              (set! g13 g214)
-              (set! g14 g215)
-              (set! g15 g216)
-              (set! g16 g217)
-              (set! g17 g218)
-              (set! g18 g219)
-              (set! g19 g220)
-              (set! g20 g221)
-              (set! g21 g222)
-              (set! g22 g223)
-              (set! g23 g224)
-              (set! g24 g225)
-              (set! g25 g226)
-              (set! g26 g227)
-              (set! g27 g228)
-              (set! g28 g229)
-              (set! g29 g230)
-              (set! g30 g231)
-              (set! g31 g232)
-              (set! g32 g233)
-              (set! g33 g234)
-              (set! g34 g235)
-              (set! g35 g236)
-              (set! g36 g237)
-              (set! g37 g238)
-              (set! g38 g239)
-              (set! g39 g240)
-              (set! g40 g241)
-              (set! g41 g242)
-              (set! g42 g243)
-              (set! g43 g244)
-              (set! g44 g245)
-              (set! g45 g246)
-              (set! g46 g247)
-              (set! g47 g248)
-              (set! g48 g249)
-              (set! g49 g250)
-              (set! g50 g251)
-              (set! g51 g252)
-              (set! g52 g253)
-              (set! g53 g254)
-              (set! g54 g255)
-              (set! g55 g256)
-              (set! g56 g257)
-              (set! g57 g258)
-              (set! g58 g259)
-              (set! g59 g260)
-              (set! g60 g261)
-              (set! g61 g262)
-              (set! g62 g263)
-              (set! g63 g264)
-              (set! g64 g265)
-              (set! g65 g266)
-              (set! g66 g267)
-              (set! g67 g268)
-              (set! g68 g269)
-              (set! g69 g270)
-              (set! g70 g271)
-              (set! g71 g272)
-              (set! g72 g273)
-              (set! g73 g274)
-              (set! g74 g275)
-              (set! g75 g276)
-              (set! g76 g277)
-              (set! g77 g278)
-              (set! g78 g279)
-              (set! g79 g280)
-              (set! g80 g281)
-              (set! g81 g282)
-              (set! g82 g283)
-              (set! g83 g284)
-              (set! g84 g285)
-              (set! g85 g286)
-              (set! g86 g287)
-              (set! g87 g288)
-              (set! g88 g289)
-              (set! g89 g290)
-              (set! g90 g291)
-              (set! g91 g292)
-              (set! g92 g293)
-              (set! g93 g294)
-              (set! g94 g295)
-              (set! g95 g296)
-              (set! g96 g297)
-              (set! g97 g298)
-              (set! g98 g299)
-              (set! g99 g300)
-              (set! g100 g301)
-              (set! g101 g302)
-              (set! g102 g303)
-              (set! g103 g304)
-              (set! g104 g305)
-              (set! g105 g306)
-              (set! g106 g307)
-              (set! g107 g308)
-              (set! g108 g309)
-              (set! g109 g310)
-              (set! g110 g311)
-              (set! g111 g312)
-              (set! g112 g313)
-              (set! g113 g314)
-              (set! g114 g315)
-              (set! g115 g316)
-              (set! g116 g317)
-              (set! g117 g318)
-              (set! g118 g319)
-              (set! g119 g320)
-              (set! g120 g321)
-              (set! g121 g322)
-              (set! g122 g323)
-              (set! g123 g324)
-              (set! g124 g325)
-              (set! g125 g326)
-              (set! g126 g327)
-              (set! g127 g328)
-              (set! g128 g329)
-              (set! g129 g330)
-              (set! g130 g331)
-              (set! g131 g332)
-              (set! g132 g333)
-              (set! g133 g334)
-              (set! g134 g335)
-              (set! g135 g336)
-              (set! g136 g337)
-              (set! g137 g338)
-              (set! g138 g339)
-              (set! g139 g340)
-              (set! g140 g341)
-              (set! g141 g342)
-              (set! g142 g343)
-              (set! g143 g344)
-              (set! g144 g345)
-              (set! g145 g346)
-              (set! g146 g347)
-              (set! g147 g348)
-              (set! g148 g349)
-              (set! g149 g350)
-              (set! g150 g351)
-              (set! g151 g352)
-              (set! g152 g353)
-              (set! g153 g354)
-              (set! g154 g355)
-              (set! g155 g356)
-              (set! g156 g357)
-              (set! g157 g358)
-              (set! g158 g359)
-              (set! g159 g360)
-              (set! g160 g361)
-              (set! g161 g362)
-              (set! g162 g363)
-              (set! g163 g364)
-              (set! g164 g365)
-              (set! g165 g366)
-              (set! g166 g367)
-              (set! g167 g368)
-              (set! g168 g369)
-              (set! g169 g370)
-              (set! g170 g371)
-              (set! g171 g372)
-              (set! g172 g373)
-              (set! g173 g374)
-              (set! g174 g375)
-              (set! g175 g376)
-              (set! g176 g377)
-              (set! g177 g378)
-              (set! g178 g379)
-              (set! g179 g380)
-              (set! g180 g381)
-              (set! g181 g382)
-              (set! g182 g383)
-              (set! g183 g384)
-              (set! g184 g385)
-              (set! g185 g386)
-              (set! g186 g387)
-              (set! g187 g388)
-              (set! g188 g389)
-              (set! g189 g390)
-              (set! g190 g391)
-              (set! g191 g392)
-              (set! g192 g393)
-              (set! g193 g394)
-              (set! g194 g395)
-              (set! g195 g396)
-              (set! g196 g397)
-              (set! g197 g398)
-              (set! g198 g399)
-              (set! g199 g400)
-              (set! g200 g401)
-              (begin
-                ((top-level-value 'primitive-set!)
-                  '$sc-put-cte
-                  (case-lambda
-                    [(g402 g403 g404)
-                     ((case-lambda
-                        [(g405 g406)
-                         ((case-lambda
-                            [(g407 g408)
-                             (begin
-                               (set! g405 g407)
-                               (set! g406 g408)
-                               ((case-lambda
-                                  [(g409)
-                                   ((case-lambda
-                                      [(g410)
-                                       (if ((top-level-value 'memv)
-                                             g410
-                                             '($module))
-                                           (begin
-                                             ((case-lambda
-                                                [(g411)
-                                                 (g405
-                                                   (g130 g411)
-                                                   (g131 g411)
-                                                   '())])
-                                               (g26 g409))
-                                             (g406 g402 g409 g404))
-                                           (if ((top-level-value 'memv)
-                                                 g410
-                                                 '(do-alias))
-                                               (g92 g402 g404 '())
-                                               (if ((top-level-value 'memv)
-                                                     g410
-                                                     '(do-import))
-                                                   ((case-lambda
-                                                      [(g412)
-                                                       ((case-lambda
-                                                          [(g413)
-                                                           ((case-lambda
-                                                              [(g414)
-                                                               (if ((top-level-value
-                                                                      'memv)
-                                                                     g414
-                                                                     '($module))
-                                                                   ((case-lambda
-                                                                      [(g415)
-                                                                       ((case-lambda
-                                                                          [(g416)
-                                                                           ((case-lambda
-                                                                              [()
-                                                                               (begin
-                                                                                 (if ((top-level-value
-                                                                                        'not)
-                                                                                       ((top-level-value
-                                                                                          'eq?)
-                                                                                         (g131
-                                                                                           g415)
-                                                                                         g412))
-                                                                                     ((top-level-value
-                                                                                        'syntax-error)
-                                                                                       g402
-                                                                                       '"import mismatch for module")
-                                                                                     (#%void))
-                                                                                 (g405
-                                                                                   (g130
-                                                                                     g415)
-                                                                                   g404
-                                                                                   (g181
-                                                                                     g402
-                                                                                     g415)))]))])
-                                                                         (g130
-                                                                           g415))])
-                                                                     (g26 g413))
-                                                                   ((top-level-value
-                                                                      'syntax-error)
-                                                                     g402
-                                                                     '"unknown module"))])
-                                                             (g25 g413))])
-                                                         (g36 (g110
-                                                                g402
-                                                                '(()))
-                                                              '()))])
-                                                     (g26 g403))
-                                                   (g406
-                                                     g402
-                                                     g409
-                                                     g404))))])
-                                     (g25 g409))])
-                                 (g37 g403)))])
-                           (case-lambda
-                             [(g417 g418 g419)
-                              (g164
-                                (case-lambda [(g420) (g92 g420 g418 g419)])
-                                g417)])
-                           (case-lambda
-                             [(g421 g422 g423)
-                              ((case-lambda
-                                 [(g424)
-                                  (begin
-                                    (g92 g421 g423 '())
-                                    (g14 g424
-                                         (if (if ((top-level-value 'eq?)
-                                                   (g25 g422)
-                                                   'global)
-                                                 ((top-level-value 'eq?)
-                                                   (g26 g422)
-                                                   g424)
-                                                 '#f)
-                                             '#f
-                                             g422)))])
-                                (if ((top-level-value 'symbol?) g421)
-                                    g421
-                                    (g110 g421 '(()))))]))])
-                       (void)
-                       (void))]))
-                (g39 'local-syntax 'letrec-syntax '#t)
-                (g39 'local-syntax 'let-syntax '#f)
-                (g39 'core
-                     'fluid-let-syntax
-                     (case-lambda
-                       [(g425 g426 g427 g428 g429 g430)
-                        ((case-lambda
-                           [(g431)
-                            ((case-lambda
-                               [(g432)
-                                (if (if g432
-                                        (#%apply
-                                          (case-lambda
-                                            [(g433 g434 g435 g436 g437)
-                                             (g115 g434)])
-                                          g432)
-                                        '#f)
-                                    (#%apply
-                                      (case-lambda
-                                        [(g438 g439 g440 g441 g442)
-                                         ((case-lambda
-                                            [(g443)
-                                             (begin
-                                               ((top-level-value 'for-each)
-                                                 (case-lambda
-                                                   [(g444 g445)
-                                                    ((case-lambda
-                                                       [(g446)
-                                                        (if ((top-level-value
-                                                               'memv)
-                                                              g446
-                                                              '(displaced-lexical))
-                                                            (g34 (g119
-                                                                   g444
-                                                                   g428))
-                                                            (#%void))])
-                                                      (g25 (g36 g445
-                                                                g426)))])
-                                                 g439
-                                                 g443)
-                                               ((case-lambda
-                                                  [(g447)
-                                                   (g179 (#%cons g441 g442)
-                                                     (g120 g425 g428 g429)
-                                                     (g31 g443 g447 g426)
-                                                     (g31 g443 g447 g427)
-                                                     g428 g430)])
-                                                 ((top-level-value 'map)
-                                                   (case-lambda
-                                                     [(g448)
-                                                      (g38 g9
-                                                           (g174 g448 g427
-                                                             g427 g428
-                                                             '#t))])
-                                                   g440)))])
-                                           ((top-level-value 'map)
-                                             (case-lambda
-                                               [(g449) (g110 g449 g428)])
-                                             g439))])
-                                      g432)
-                                    ((case-lambda
-                                       [(g450)
-                                        ((top-level-value 'syntax-error)
-                                          (g120 g425 g428 g429))])
-                                      g431))])
-                              (#%$syntax-dispatch
-                                g431
-                                '(any #(each (any any)) any . each-any)))])
-                          g425)]))
-                (g39 'core
-                     'quote
-                     (case-lambda
-                       [(g451 g452 g453 g454 g455 g456)
-                        ((case-lambda
-                           [(g457)
-                            ((case-lambda
-                               [(g458)
-                                (if g458
-                                    (#%apply
-                                      (case-lambda
-                                        [(g459 g460)
-                                         ((top-level-value 'list)
-                                           'quote
-                                           (g198 g460 g454))])
-                                      g458)
-                                    ((case-lambda
-                                       [(g461)
-                                        ((top-level-value 'syntax-error)
-                                          (g120 g451 g454 g455))])
-                                      g457))])
-                              (#%$syntax-dispatch g457 '(any any)))])
-                          g451)]))
-                (g39 'core
-                     '|#primitive|
-                     (case-lambda
-                       [(g462 g463 g464 g465 g466 g467)
-                        ((case-lambda
-                           [(g468)
-                            ((case-lambda
-                               [(g469)
-                                (if (if g469
-                                        (#%apply
-                                          (case-lambda
-                                            [(g470 g471) (g41 g471)])
-                                          g469)
-                                        '#f)
-                                    (#%apply
-                                      (case-lambda
-                                        [(g472 g473)
-                                         ((top-level-value 'list)
-                                           '|#primitive|
-                                           (g198 g473 g465))])
-                                      g469)
-                                    ((case-lambda
-                                       [(g474)
-                                        ((top-level-value 'syntax-error)
-                                          (g120 g462 g465 g466))])
-                                      g468))])
-                              (#%$syntax-dispatch g468 '(any any)))])
-                          g462)]))
-                (g39 'core
-                     'syntax
-                     ((case-lambda
-                        [()
-                         ((case-lambda
-                            [(g475 g476 g477 g478 g479 g480 g481 g482)
-                             ((case-lambda
-                                [(g483 g484 g485 g486 g487 g488 g489 g490)
-                                 (begin
-                                   (set! g475 g483)
-                                   (set! g476 g484)
-                                   (set! g477 g485)
-                                   (set! g478 g486)
-                                   (set! g479 g487)
-                                   (set! g480 g488)
-                                   (set! g481 g489)
-                                   (set! g482 g490)
-                                   (case-lambda
-                                     [(g491 g492 g493 g494 g495 g496)
-                                      ((case-lambda
-                                         [(g497)
-                                          ((case-lambda
-                                             [(g498)
-                                              ((case-lambda
-                                                 [(g499)
-                                                  (if g499
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g500 g501)
-                                                           ((top-level-value
-                                                              'call-with-values)
-                                                             (case-lambda
-                                                               [()
-                                                                (g475 g497
-                                                                  g501 g492
-                                                                  '() g195
-                                                                  '#f)])
-                                                             (case-lambda
-                                                               [(g502 g503)
-                                                                (g482
-                                                                  g502)]))])
-                                                        g499)
-                                                      ((case-lambda
-                                                         [(g504)
-                                                          ((top-level-value
-                                                             'syntax-error)
-                                                            g497)])
-                                                        g498))])
-                                                (#%$syntax-dispatch
-                                                  g498
-                                                  '(any any)))])
-                                            g497)])
-                                        (g120 g491 g494 g495))]))])
-                               (case-lambda
-                                 [(g505 g506 g507 g508 g509 g510)
-                                  (if (g41 g506)
-                                      ((case-lambda
-                                         [(g511)
-                                          ((case-lambda
-                                             [(g512)
-                                              (if ((top-level-value 'eq?)
-                                                    (g25 g512)
-                                                    'syntax)
-                                                  ((top-level-value
-                                                     'call-with-values)
-                                                    (case-lambda
-                                                      [()
-                                                       ((case-lambda
-                                                          [(g513)
-                                                           (g476
-                                                             g505
-                                                             ((top-level-value
-                                                                'car)
-                                                               g513)
-                                                             ((top-level-value
-                                                                'cdr)
-                                                               g513)
-                                                             g508)])
-                                                         (g26 g512))])
-                                                    (case-lambda
-                                                      [(g514 g515)
-                                                       ((top-level-value
-                                                          'values)
-                                                         ((top-level-value
-                                                            'list)
-                                                           'ref
-                                                           g514)
-                                                         g515)]))
-                                                  (if (g509 g506)
-                                                      ((top-level-value
-                                                         'syntax-error)
-                                                        g505
-                                                        '"misplaced ellipsis in syntax form")
-                                                      ((top-level-value
-                                                         'values)
-                                                        ((top-level-value
-                                                           'list)
-                                                          'quote
-                                                          g506)
-                                                        g508)))])
-                                            (g36 g511 g507))])
-                                        (g110 g506 '(())))
-                                      ((case-lambda
-                                         [(g516)
-                                          ((case-lambda
-                                             [(g517)
-                                              (if (if g517
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g518 g519)
-                                                           (g509 g518)])
-                                                        g517)
-                                                      '#f)
-                                                  (#%apply
-                                                    (case-lambda
-                                                      [(g520 g521)
-                                                       (if g510
-                                                           ((top-level-value
-                                                              'syntax-error)
-                                                             g505
-                                                             '"misplaced ellipsis in syntax template")
-                                                           (g475 g505 g521
-                                                             g507 g508
-                                                             (case-lambda
-                                                               [(g522)
-                                                                '#f])
-                                                             '#f))])
-                                                    g517)
-                                                  ((case-lambda
-                                                     [(g523)
-                                                      (if (if g523
-                                                              (#%apply
-                                                                (case-lambda
-                                                                  [(g524
-                                                                    g525
-                                                                    g526)
-                                                                   (g509
-                                                                     g525)])
-                                                                g523)
-                                                              '#f)
-                                                          (#%apply
-                                                            (case-lambda
-                                                              [(g527 g528
-                                                                g529)
-                                                               (((case-lambda
-                                                                   [(g530)
-                                                                    ((case-lambda
-                                                                       [(g531)
-                                                                        (begin
-                                                                          (set! g530
-                                                                            g531)
-                                                                          g530)])
-                                                                      (case-lambda
-                                                                        [(g532
-                                                                          g533)
-                                                                         ((case-lambda
-                                                                            [(g534)
-                                                                             ((case-lambda
-                                                                                [(g535)
-                                                                                 (if (if g535
-                                                                                         (#%apply
-                                                                                           (case-lambda
-                                                                                             [(g536
-                                                                                               g537)
-                                                                                              (g509
-                                                                                                g536)])
-                                                                                           g535)
-                                                                                         '#f)
-                                                                                     (#%apply
-                                                                                       (case-lambda
-                                                                                         [(g538
-                                                                                           g539)
-                                                                                          (g530
-                                                                                            g539
-                                                                                            (case-lambda
-                                                                                              [(g540)
-                                                                                               ((top-level-value
-                                                                                                  'call-with-values)
-                                                                                                 (case-lambda
-                                                                                                   [()
-                                                                                                    (g533
-                                                                                                      ((top-level-value
-                                                                                                         'cons)
-                                                                                                        '()
-                                                                                                        g540))])
-                                                                                                 (case-lambda
-                                                                                                   [(g541
-                                                                                                     g542)
-                                                                                                    (if ((top-level-value
-                                                                                                           'null?)
-                                                                                                          ((top-level-value
-                                                                                                             'car)
-                                                                                                            g542))
-                                                                                                        ((top-level-value
-                                                                                                           'syntax-error)
-                                                                                                          g505
-                                                                                                          '"extra ellipsis in syntax form")
-                                                                                                        ((top-level-value
-                                                                                                           'values)
-                                                                                                          (g478
-                                                                                                            g541
-                                                                                                            ((top-level-value
-                                                                                                               'car)
-                                                                                                              g542))
-                                                                                                          ((top-level-value
-                                                                                                             'cdr)
-                                                                                                            g542)))]))]))])
-                                                                                       g535)
-                                                                                     ((case-lambda
-                                                                                        [(g543)
-                                                                                         ((top-level-value
-                                                                                            'call-with-values)
-                                                                                           (case-lambda
-                                                                                             [()
-                                                                                              (g475
-                                                                                                g505
-                                                                                                g532
-                                                                                                g507
-                                                                                                g508
-                                                                                                g509
-                                                                                                g510)])
-                                                                                           (case-lambda
-                                                                                             [(g544
-                                                                                               g545)
-                                                                                              ((top-level-value
-                                                                                                 'call-with-values)
-                                                                                                (case-lambda
-                                                                                                  [()
-                                                                                                   (g533
-                                                                                                     g545)])
-                                                                                                (case-lambda
-                                                                                                  [(g546
-                                                                                                    g547)
-                                                                                                   ((top-level-value
-                                                                                                      'values)
-                                                                                                     (g477
-                                                                                                       g546
-                                                                                                       g544)
-                                                                                                     g547)]))]))])
-                                                                                       g534))])
-                                                                               (#%$syntax-dispatch
-                                                                                 g534
-                                                                                 '(any .
-                                                                                       any)))])
-                                                                           g532)]))])
-                                                                  (void))
-                                                                 g529
-                                                                 (case-lambda
-                                                                   [(g548)
-                                                                    ((top-level-value
-                                                                       'call-with-values)
-                                                                      (case-lambda
-                                                                        [()
-                                                                         (g475
-                                                                           g505
-                                                                           g527
-                                                                           g507
-                                                                           ((top-level-value
-                                                                              'cons)
-                                                                             '()
-                                                                             g548)
-                                                                           g509
-                                                                           '#f)])
-                                                                      (case-lambda
-                                                                        [(g549
-                                                                          g550)
-                                                                         (if ((top-level-value
-                                                                                'null?)
-                                                                               ((top-level-value
-                                                                                  'car)
-                                                                                 g550))
-                                                                             ((top-level-value
-                                                                                'syntax-error)
-                                                                               g505
-                                                                               '"extra ellipsis in syntax form")
-                                                                             ((top-level-value
-                                                                                'values)
-                                                                               (g479
-                                                                                 g549
-                                                                                 ((top-level-value
-                                                                                    'car)
-                                                                                   g550))
-                                                                               ((top-level-value
-                                                                                  'cdr)
-                                                                                 g550)))]))]))])
-                                                            g523)
-                                                          ((case-lambda
-                                                             [(g551)
-                                                              (if g551
-                                                                  (#%apply
-                                                                    (case-lambda
-                                                                      [(g552
-                                                                        g553)
-                                                                       ((top-level-value
-                                                                          'call-with-values)
-                                                                         (case-lambda
-                                                                           [()
-                                                                            (g475
-                                                                              g505
-                                                                              g552
-                                                                              g507
-                                                                              g508
-                                                                              g509
-                                                                              '#f)])
-                                                                         (case-lambda
-                                                                           [(g554
-                                                                             g555)
-                                                                            ((top-level-value
-                                                                               'call-with-values)
-                                                                              (case-lambda
-                                                                                [()
-                                                                                 (g475
-                                                                                   g505
-                                                                                   g553
-                                                                                   g507
-                                                                                   g555
-                                                                                   g509
-                                                                                   g510)])
-                                                                              (case-lambda
-                                                                                [(g556
-                                                                                  g557)
-                                                                                 ((top-level-value
-                                                                                    'values)
-                                                                                   (g480
-                                                                                     g506
-                                                                                     g552
-                                                                                     g553
-                                                                                     g554
-                                                                                     g556)
-                                                                                   g557)]))]))])
-                                                                    g551)
-                                                                  ((case-lambda
-                                                                     [(g558)
-                                                                      (if g558
-                                                                          (#%apply
-                                                                            (case-lambda
-                                                                              [(g559
-                                                                                g560)
-                                                                               ((case-lambda
-                                                                                  [(g561)
-                                                                                   ((top-level-value
-                                                                                      'call-with-values)
-                                                                                     (case-lambda
-                                                                                       [()
-                                                                                        (g475
-                                                                                          g505
-                                                                                          g561
-                                                                                          g507
-                                                                                          g508
-                                                                                          g509
-                                                                                          '#t)])
-                                                                                     (case-lambda
-                                                                                       [(g562
-                                                                                         g563)
-                                                                                        ((top-level-value
-                                                                                           'values)
-                                                                                          (g481
-                                                                                            g506
-                                                                                            g561
-                                                                                            g562)
-                                                                                          g563)]))])
-                                                                                 (#%cons
-                                                                                   g559
-                                                                                   g560))])
-                                                                            g558)
-                                                                          ((case-lambda
-                                                                             [(g564)
-                                                                              ((top-level-value
-                                                                                 'values)
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  'quote
-                                                                                  g506)
-                                                                                g508)])
-                                                                            g516))])
-                                                                    (#%$syntax-dispatch
-                                                                      g516
-                                                                      '#(vector
-                                                                         (any .
-                                                                              each-any)))))])
-                                                            (#%$syntax-dispatch
-                                                              g516
-                                                              '(any .
-                                                                    any))))])
-                                                    (#%$syntax-dispatch
-                                                      g516
-                                                      '(any any . any))))])
-                                            (#%$syntax-dispatch
-                                              g516
-                                              '(any any)))])
-                                        g506))])
-                               (case-lambda
-                                 [(g565 g566 g567 g568)
-                                  (if ((top-level-value 'fx=) g567 '0)
-                                      ((top-level-value 'values) g566 g568)
-                                      (if ((top-level-value 'null?) g568)
-                                          ((top-level-value 'syntax-error)
-                                            g565
-                                            '"missing ellipsis in syntax form")
-                                          ((top-level-value
-                                             'call-with-values)
-                                            (case-lambda
-                                              [()
-                                               (g476
-                                                 g565
-                                                 g566
-                                                 ((top-level-value 'fx-)
-                                                   g567
-                                                   '1)
-                                                 ((top-level-value 'cdr)
-                                                   g568))])
-                                            (case-lambda
-                                              [(g569 g570)
-                                               ((case-lambda
-                                                  [(g571)
-                                                   (if g571
-                                                       ((top-level-value
-                                                          'values)
-                                                         ((top-level-value
-                                                            'cdr)
-                                                           g571)
-                                                         g568)
-                                                       ((case-lambda
-                                                          [(g572)
-                                                           ((top-level-value
-                                                              'values)
-                                                             g572
-                                                             ((top-level-value
-                                                                'cons)
-                                                               ((top-level-value
-                                                                  'cons)
-                                                                 ((top-level-value
-                                                                    'cons)
-                                                                   g569
-                                                                   g572)
-                                                                 ((top-level-value
-                                                                    'car)
-                                                                   g568))
-                                                               g570))])
-                                                         (g199 'tmp)))])
-                                                 ((top-level-value 'assq)
-                                                   g569
-                                                   ((top-level-value 'car)
-                                                     g568)))]))))])
-                               (case-lambda
-                                 [(g573 g574)
-                                  (if ((top-level-value 'equal?) g574 ''())
-                                      g573
-                                      ((top-level-value 'list)
-                                        'append
-                                        g573
-                                        g574))])
-                               (case-lambda
-                                 [(g575 g576)
-                                  ((top-level-value 'list)
-                                    'apply
-                                    '(primitive append)
-                                    (g479 g575 g576))])
-                               (case-lambda
-                                 [(g577 g578)
-                                  ((case-lambda
-                                     [(g579 g580)
-                                      (if ((top-level-value 'eq?)
-                                            ((top-level-value 'car) g577)
-                                            'ref)
-                                          ((top-level-value 'car) g580)
-                                          (if ((top-level-value 'andmap)
-                                                (case-lambda
-                                                  [(g581)
-                                                   (if ((top-level-value
-                                                          'eq?)
-                                                         ((top-level-value
-                                                            'car)
-                                                           g581)
-                                                         'ref)
-                                                       ((top-level-value
-                                                          'memq)
-                                                         ((top-level-value
-                                                            'cadr)
-                                                           g581)
-                                                         g579)
-                                                       '#f)])
-                                                ((top-level-value 'cdr)
-                                                  g577))
-                                              ((top-level-value 'cons)
-                                                'map
-                                                ((top-level-value 'cons)
-                                                  ((top-level-value 'list)
-                                                    'primitive
-                                                    ((top-level-value 'car)
-                                                      g577))
-                                                  ((top-level-value 'map)
-                                                    ((case-lambda
-                                                       [(g582)
-                                                        (case-lambda
-                                                          [(g583)
-                                                           ((top-level-value
-                                                              'cdr)
-                                                             ((top-level-value
-                                                                'assq)
-                                                               ((top-level-value
-                                                                  'cadr)
-                                                                 g583)
-                                                               g582))])])
-                                                      ((top-level-value
-                                                         'map)
-                                                        (top-level-value
-                                                          'cons)
-                                                        g579
-                                                        g580))
-                                                    ((top-level-value 'cdr)
-                                                      g577))))
-                                              ((top-level-value 'cons)
-                                                'map
-                                                ((top-level-value 'cons)
-                                                  ((top-level-value 'list)
-                                                    'lambda
-                                                    g579
-                                                    g577)
-                                                  g580))))])
-                                    ((top-level-value 'map)
-                                      (top-level-value 'cdr)
-                                      g578)
-                                    ((top-level-value 'map)
-                                      (case-lambda
-                                        [(g584)
-                                         ((top-level-value 'list)
-                                           'ref
-                                           ((top-level-value 'car) g584))])
-                                      g578))])
-                               (case-lambda
-                                 [(g585 g586 g587 g588 g589)
-                                  ((case-lambda
-                                     [(g590)
-                                      (if ((top-level-value 'memv)
-                                            g590
-                                            '(quote))
-                                          (if ((top-level-value 'eq?)
-                                                ((top-level-value 'car)
-                                                  g588)
-                                                'quote)
-                                              ((case-lambda
-                                                 [(g591 g592)
-                                                  (if (if ((top-level-value
-                                                             'eq?)
-                                                            g591
-                                                            g586)
-                                                          ((top-level-value
-                                                             'eq?)
-                                                            g592
-                                                            g587)
-                                                          '#f)
-                                                      ((top-level-value
-                                                         'list)
-                                                        'quote
-                                                        g585)
-                                                      ((top-level-value
-                                                         'list)
-                                                        'quote
-                                                        ((top-level-value
-                                                           'cons)
-                                                          g591
-                                                          g592)))])
-                                                ((top-level-value 'cadr)
-                                                  g588)
-                                                ((top-level-value 'cadr)
-                                                  g589))
-                                              (if ((top-level-value 'eq?)
-                                                    ((top-level-value
-                                                       'cadr)
-                                                      g589)
-                                                    '())
-                                                  ((top-level-value 'list)
-                                                    'list
-                                                    g588)
-                                                  ((top-level-value 'list)
-                                                    'cons
-                                                    g588
-                                                    g589)))
-                                          (if ((top-level-value 'memv)
-                                                g590
-                                                '(list))
-                                              ((top-level-value 'cons)
-                                                'list
-                                                ((top-level-value 'cons)
-                                                  g588
-                                                  ((top-level-value 'cdr)
-                                                    g589)))
-                                              ((top-level-value 'list)
-                                                'cons
-                                                g588
-                                                g589)))])
-                                    ((top-level-value 'car) g589))])
-                               (case-lambda
-                                 [(g593 g594 g595)
-                                  (if ((top-level-value 'eq?)
-                                        ((top-level-value 'car) g595)
-                                        'quote)
-                                      (if ((top-level-value 'eq?)
-                                            ((top-level-value 'cadr) g595)
-                                            g594)
-                                          ((top-level-value 'list)
-                                            'quote
-                                            g593)
-                                          ((top-level-value 'list)
-                                            'quote
-                                            ((top-level-value
-                                               'list->vector)
-                                              ((top-level-value 'cadr)
-                                                g595))))
-                                      (if ((top-level-value 'eq?)
-                                            ((top-level-value 'car) g595)
-                                            'list)
-                                          ((top-level-value 'cons)
-                                            'vector
-                                            ((top-level-value 'cdr) g595))
-                                          ((top-level-value 'list)
-                                            'list->vector
-                                            g595)))])
-                               (case-lambda
-                                 [(g596)
-                                  ((case-lambda
-                                     [(g597)
-                                      (if ((top-level-value 'memv)
-                                            g597
-                                            '(ref))
-                                          ((top-level-value 'cadr) g596)
-                                          (if ((top-level-value 'memv)
-                                                g597
-                                                '(primitive))
-                                              ((top-level-value 'list)
-                                                '|#primitive|
-                                                ((top-level-value 'cadr)
-                                                  g596))
-                                              (if ((top-level-value 'memv)
-                                                    g597
-                                                    '(quote))
-                                                  ((top-level-value 'list)
-                                                    'quote
-                                                    ((top-level-value
-                                                       'cadr)
-                                                      g596))
-                                                  (if ((top-level-value
-                                                         'memv)
-                                                        g597
-                                                        '(lambda))
-                                                      ((top-level-value
-                                                         'list)
-                                                        'case-lambda
-                                                        ((top-level-value
-                                                           'list)
-                                                          ((top-level-value
-                                                             'cadr)
-                                                            g596)
-                                                          (g482
-                                                            ((top-level-value
-                                                               'caddr)
-                                                              g596))))
-                                                      (if ((top-level-value
-                                                             'memv)
-                                                            g597
-                                                            '(map))
-                                                          ((case-lambda
-                                                             [(g598)
-                                                              ((top-level-value
-                                                                 'cons)
-                                                                (if ((top-level-value
-                                                                       'fx=)
-                                                                      ((top-level-value
-                                                                         'length)
-                                                                        g598)
-                                                                      '2)
-                                                                    '#%map
-                                                                    '#%map)
-                                                                g598)])
-                                                            ((top-level-value
-                                                               'map)
-                                                              g482
-                                                              ((top-level-value
-                                                                 'cdr)
-                                                                g596)))
-                                                          ((top-level-value
-                                                             'cons)
-                                                            ((top-level-value
-                                                               'list)
-                                                              '|#primitive|
-                                                              ((top-level-value
-                                                                 'car)
-                                                                g596))
-                                                            ((top-level-value
-                                                               'map)
-                                                              g482
-                                                              ((top-level-value
-                                                                 'cdr)
-                                                                g596))))))))])
-                                    ((top-level-value 'car) g596))]))])
-                           (void) (void) (void) (void) (void) (void) (void)
-                           (void))])))
-                (g39 'core
-                     'lambda
-                     (case-lambda
-                       [(g599 g600 g601 g602 g603 g604)
-                        ((case-lambda
-                           [(g605)
-                            ((case-lambda
-                               [(g606)
-                                (if g606
-                                    (#%apply
-                                      (case-lambda
-                                        [(g607 g608)
-                                         ((top-level-value
-                                            'call-with-values)
-                                           (case-lambda
-                                             [()
-                                              (g192 (g120 g599 g602 g603)
-                                                g608 g600 g601 g602 g604)])
-                                           (case-lambda
-                                             [(g609 g610)
-                                              ((top-level-value 'list)
-                                                'case-lambda
-                                                ((top-level-value 'list)
-                                                  g609
-                                                  g610))]))])
-                                      g606)
-                                    (#%syntax-error g605))])
-                              (#%$syntax-dispatch g605 '(any . any)))])
-                          g599)]))
-                (g39 'core
-                     'letrec
-                     (case-lambda
-                       [(g611 g612 g613 g614 g615 g616)
-                        ((case-lambda
-                           [(g617)
-                            ((case-lambda
-                               [(g618)
-                                (if g618
-                                    (#%apply
-                                      (case-lambda
-                                        [(g619 g620 g621 g622 g623)
-                                         ((case-lambda
-                                            [(g624)
-                                             (if ((top-level-value 'not)
-                                                   (g115 g624))
-                                                 (g117
-                                                   ((top-level-value 'map)
-                                                     (case-lambda
-                                                       [(g625)
-                                                        (g119 g625 g614)])
-                                                     g624)
-                                                   (g120 g611 g614 g615)
-                                                   '"bound variable")
-                                                 ((case-lambda
-                                                    [(g626 g627)
-                                                     ((case-lambda
-                                                        [(g628 g629)
-                                                         (g21 g615
-                                                              g627
-                                                              ((top-level-value
-                                                                 'map)
-                                                                (case-lambda
-                                                                  [(g630)
-                                                                   (g174
-                                                                     g630
-                                                                     g629
-                                                                     g613
-                                                                     g628
-                                                                     g616)])
-                                                                g621)
-                                                              (g179
-                                                                (#%cons
-                                                                  g622
-                                                                  g623)
-                                                                (g120
-                                                                  g611
-                                                                  g628
-                                                                  g615)
-                                                                g629 g613
-                                                                g628
-                                                                g616))])
-                                                       (g93 g624 g626 g614)
-                                                       (g32 g626
-                                                            g627
-                                                            g612))])
-                                                   (g57 g624)
-                                                   ((top-level-value 'map)
-                                                     g199
-                                                     g624)))])
-                                           g620)])
-                                      g618)
-                                    ((case-lambda
-                                       [(g631)
-                                        ((top-level-value 'syntax-error)
-                                          (g120 g611 g614 g615))])
-                                      g617))])
-                              (#%$syntax-dispatch
-                                g617
-                                '(any #(each (any any)) any . each-any)))])
-                          g611)]))
-                (g39 'core
-                     'if
-                     (case-lambda
-                       [(g632 g633 g634 g635 g636 g637)
-                        ((case-lambda
-                           [(g638)
-                            ((case-lambda
-                               [(g639)
-                                (if g639
-                                    (#%apply
-                                      (case-lambda
-                                        [(g640 g641 g642)
-                                         ((top-level-value 'list)
-                                           'if
-                                           (g174 g641 g633 g634 g635 g637)
-                                           (g174 g642 g633 g634 g635 g637)
-                                           (g194))])
-                                      g639)
-                                    ((case-lambda
-                                       [(g643)
-                                        (if g643
-                                            (#%apply
-                                              (case-lambda
-                                                [(g644 g645 g646 g647)
-                                                 ((top-level-value 'list)
-                                                   'if
-                                                   (g174 g645 g633 g634
-                                                     g635 g637)
-                                                   (g174 g646 g633 g634
-                                                     g635 g637)
-                                                   (g174 g647 g633 g634
-                                                     g635 g637))])
-                                              g643)
-                                            ((case-lambda
-                                               [(g648)
-                                                ((top-level-value
-                                                   'syntax-error)
-                                                  (g120 g632 g635 g636))])
-                                              g638))])
-                                      (#%$syntax-dispatch
-                                        g638
-                                        '(any any any any))))])
-                              (#%$syntax-dispatch g638 '(any any any)))])
-                          g632)]))
-                (g39 'set! 'set! '())
-                (g39 'alias 'alias '())
-                (g39 'begin 'begin '())
-                (g39 '$module-key '$module '())
-                (g39 '$import '$import '())
-                (g39 'define 'define '())
-                (g39 'define-syntax 'define-syntax '())
-                (g39 'eval-when 'eval-when '())
-                (g39 'meta 'meta '())
-                (g39 'core
-                     'syntax-case
-                     ((case-lambda
-                        [()
-                         ((case-lambda
-                            [(g649 g650 g651 g652)
-                             ((case-lambda
-                                [(g653 g654 g655 g656)
-                                 (begin
-                                   (set! g649 g653)
-                                   (set! g650 g654)
-                                   (set! g651 g655)
-                                   (set! g652 g656)
-                                   (case-lambda
-                                     [(g657 g658 g659 g660 g661 g662)
-                                      ((case-lambda
-                                         [(g663)
-                                          ((case-lambda
-                                             [(g664)
-                                              ((case-lambda
-                                                 [(g665)
-                                                  (if g665
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g666 g667 g668
-                                                            g669)
-                                                           (if ((top-level-value
-                                                                  'andmap)
-                                                                 (case-lambda
-                                                                   [(g670)
-                                                                    (if (g41 g670)
-                                                                        ((top-level-value
-                                                                           'not)
-                                                                          (g195
-                                                                            g670))
-                                                                        '#f)])
-                                                                 g668)
-                                                               ((case-lambda
-                                                                  [(g671)
-                                                                   ((top-level-value
-                                                                      'list)
-                                                                     ((top-level-value
-                                                                        'list)
-                                                                       'case-lambda
-                                                                       ((top-level-value
-                                                                          'list)
-                                                                         ((top-level-value
-                                                                            'list)
-                                                                           g671)
-                                                                         (g652
-                                                                           g671
-                                                                           g668
-                                                                           g669
-                                                                           g658
-                                                                           g659
-                                                                           g662)))
-                                                                     (g174
-                                                                       g667
-                                                                       g658
-                                                                       g659
-                                                                       '(())
-                                                                       g662))])
-                                                                 (g199
-                                                                   'tmp))
-                                                               ((top-level-value
-                                                                  'syntax-error)
-                                                                 g663
-                                                                 '"invalid literals list in"))])
-                                                        g665)
-                                                      (#%syntax-error
-                                                        g664))])
-                                                (#%$syntax-dispatch
-                                                  g664
-                                                  '(any any
-                                                        each-any
-                                                        .
-                                                        each-any)))])
-                                            g663)])
-                                        (g120 g657 g660 g661))]))])
-                               (case-lambda
-                                 [(g672 g673)
-                                  ((case-lambda
-                                     [(g674 g675)
-                                      ((case-lambda
-                                         [(g676 g677)
-                                          (begin
-                                            (set! g674 g676)
-                                            (set! g675 g677)
-                                            (g675 g672 '0 '()))])
-                                        (case-lambda
-                                          [(g678 g679 g680)
-                                           (if ((top-level-value 'null?)
-                                                 g678)
-                                               ((top-level-value 'values)
-                                                 '()
-                                                 g680)
-                                               ((top-level-value
-                                                  'call-with-values)
-                                                 (case-lambda
-                                                   [()
-                                                    (g674
-                                                      ((top-level-value
-                                                         'cdr)
-                                                        g678)
-                                                      g679
-                                                      g680)])
-                                                 (case-lambda
-                                                   [(g681 g682)
-                                                    ((top-level-value
-                                                       'call-with-values)
-                                                      (case-lambda
-                                                        [()
-                                                         (g675
-                                                           ((top-level-value
-                                                              'car)
-                                                             g678)
-                                                           g679
-                                                           g682)])
-                                                      (case-lambda
-                                                        [(g683 g684)
-                                                         ((top-level-value
-                                                            'values)
-                                                           ((top-level-value
-                                                              'cons)
-                                                             g683
-                                                             g681)
-                                                           g684)]))])))])
-                                        (case-lambda
-                                          [(g685 g686 g687)
-                                           (if (g41 g685)
-                                               (if (g118 g685 g673)
-                                                   ((top-level-value
-                                                      'values)
-                                                     ((top-level-value
-                                                        'vector)
-                                                       'free-id
-                                                       g685)
-                                                     g687)
-                                                   ((top-level-value
-                                                      'values)
-                                                     'any
-                                                     ((top-level-value
-                                                        'cons)
-                                                       ((top-level-value
-                                                          'cons)
-                                                         g685
-                                                         g686)
-                                                       g687)))
-                                               ((case-lambda
-                                                  [(g688)
-                                                   ((case-lambda
-                                                      [(g689)
-                                                       (if (if g689
-                                                               (#%apply
-                                                                 (case-lambda
-                                                                   [(g690
-                                                                     g691)
-                                                                    (g195
-                                                                      g691)])
-                                                                 g689)
-                                                               '#f)
-                                                           (#%apply
-                                                             (case-lambda
-                                                               [(g692 g693)
-                                                                ((top-level-value
-                                                                   'call-with-values)
-                                                                  (case-lambda
-                                                                    [()
-                                                                     (g675
-                                                                       g692
-                                                                       ((top-level-value
-                                                                          'fx+)
-                                                                         g686
-                                                                         '1)
-                                                                       g687)])
-                                                                  (case-lambda
-                                                                    [(g694
-                                                                      g695)
-                                                                     ((top-level-value
-                                                                        'values)
-                                                                       (if ((top-level-value
-                                                                              'eq?)
-                                                                             g694
-                                                                             'any)
-                                                                           'each-any
-                                                                           ((top-level-value
-                                                                              'vector)
-                                                                             'each
-                                                                             g694))
-                                                                       g695)]))])
-                                                             g689)
-                                                           ((case-lambda
-                                                              [(g696)
-                                                               (if (if g696
-                                                                       (#%apply
-                                                                         (case-lambda
-                                                                           [(g697
-                                                                             g698
-                                                                             g699
-                                                                             g700)
-                                                                            (g195
-                                                                              g698)])
-                                                                         g696)
-                                                                       '#f)
-                                                                   (#%apply
-                                                                     (case-lambda
-                                                                       [(g701
-                                                                         g702
-                                                                         g703
-                                                                         g704)
-                                                                        ((top-level-value
-                                                                           'call-with-values)
-                                                                          (case-lambda
-                                                                            [()
-                                                                             (g675
-                                                                               g704
-                                                                               g686
-                                                                               g687)])
-                                                                          (case-lambda
-                                                                            [(g705
-                                                                              g706)
-                                                                             ((top-level-value
-                                                                                'call-with-values)
-                                                                               (case-lambda
-                                                                                 [()
-                                                                                  (g674
-                                                                                    g703
-                                                                                    g686
-                                                                                    g706)])
-                                                                               (case-lambda
-                                                                                 [(g707
-                                                                                   g708)
-                                                                                  ((top-level-value
-                                                                                     'call-with-values)
-                                                                                    (case-lambda
-                                                                                      [()
-                                                                                       (g675
-                                                                                         g701
-                                                                                         ((top-level-value
-                                                                                            'fx+)
-                                                                                           g686
-                                                                                           '1)
-                                                                                         g708)])
-                                                                                    (case-lambda
-                                                                                      [(g709
-                                                                                        g710)
-                                                                                       ((top-level-value
-                                                                                          'values)
-                                                                                         ((top-level-value
-                                                                                            'vector)
-                                                                                           'each+
-                                                                                           g709
-                                                                                           ((top-level-value
-                                                                                              'reverse)
-                                                                                             g707)
-                                                                                           g705)
-                                                                                         g710)]))]))]))])
-                                                                     g696)
-                                                                   ((case-lambda
-                                                                      [(g711)
-                                                                       (if g711
-                                                                           (#%apply
-                                                                             (case-lambda
-                                                                               [(g712
-                                                                                 g713)
-                                                                                ((top-level-value
-                                                                                   'call-with-values)
-                                                                                  (case-lambda
-                                                                                    [()
-                                                                                     (g675
-                                                                                       g713
-                                                                                       g686
-                                                                                       g687)])
-                                                                                  (case-lambda
-                                                                                    [(g714
-                                                                                      g715)
-                                                                                     ((top-level-value
-                                                                                        'call-with-values)
-                                                                                       (case-lambda
-                                                                                         [()
-                                                                                          (g675
-                                                                                            g712
-                                                                                            g686
-                                                                                            g715)])
-                                                                                       (case-lambda
-                                                                                         [(g716
-                                                                                           g717)
-                                                                                          ((top-level-value
-                                                                                             'values)
-                                                                                            ((top-level-value
-                                                                                               'cons)
-                                                                                              g716
-                                                                                              g714)
-                                                                                            g717)]))]))])
-                                                                             g711)
-                                                                           ((case-lambda
-                                                                              [(g718)
-                                                                               (if g718
-                                                                                   (#%apply
-                                                                                     (case-lambda
-                                                                                       [()
-                                                                                        ((top-level-value
-                                                                                           'values)
-                                                                                          '()
-                                                                                          g687)])
-                                                                                     g718)
-                                                                                   ((case-lambda
-                                                                                      [(g719)
-                                                                                       (if g719
-                                                                                           (#%apply
-                                                                                             (case-lambda
-                                                                                               [(g720)
-                                                                                                ((top-level-value
-                                                                                                   'call-with-values)
-                                                                                                  (case-lambda
-                                                                                                    [()
-                                                                                                     (g675
-                                                                                                       g720
-                                                                                                       g686
-                                                                                                       g687)])
-                                                                                                  (case-lambda
-                                                                                                    [(g721
-                                                                                                      g722)
-                                                                                                     ((top-level-value
-                                                                                                        'values)
-                                                                                                       ((top-level-value
-                                                                                                          'vector)
-                                                                                                         'vector
-                                                                                                         g721)
-                                                                                                       g722)]))])
-                                                                                             g719)
-                                                                                           ((case-lambda
-                                                                                              [(g723)
-                                                                                               ((top-level-value
-                                                                                                  'values)
-                                                                                                 ((top-level-value
-                                                                                                    'vector)
-                                                                                                   'atom
-                                                                                                   (g198
-                                                                                                     g685
-                                                                                                     '(())))
-                                                                                                 g687)])
-                                                                                             g688))])
-                                                                                     (#%$syntax-dispatch
-                                                                                       g688
-                                                                                       '#(vector
-                                                                                          each-any))))])
-                                                                             (#%$syntax-dispatch
-                                                                               g688
-                                                                               '())))])
-                                                                     (#%$syntax-dispatch
-                                                                       g688
-                                                                       '(any .
-                                                                             any))))])
-                                                             (#%$syntax-dispatch
-                                                               g688
-                                                               '(any any
-                                                                     .
-                                                                     #(each+
-                                                                       any
-                                                                       ()
-                                                                       any)))))])
-                                                     (#%$syntax-dispatch
-                                                       g688
-                                                       '(any any)))])
-                                                 g685))]))])
-                                    (void)
-                                    (void))])
-                               (case-lambda
-                                 [(g724 g725 g726 g727 g728 g729)
-                                  ((case-lambda
-                                     [(g730 g731)
-                                      ((case-lambda
-                                         [(g732 g733)
-                                          ((top-level-value 'list)
-                                            '#%apply
-                                            ((top-level-value 'list)
-                                              'case-lambda
-                                              ((top-level-value 'list)
-                                                g733
-                                                (g174 g725
-                                                  (g31 g732
-                                                       ((top-level-value
-                                                          'map)
-                                                         (case-lambda
-                                                           [(g734 g735)
-                                                            ((top-level-value
-                                                               'cons)
-                                                              'syntax
-                                                              ((top-level-value
-                                                                 'cons)
-                                                                g734
-                                                                g735))])
-                                                         g733
-                                                         ((top-level-value
-                                                            'map)
-                                                           (top-level-value
-                                                             'cdr)
-                                                           g724))
-                                                       g727)
-                                                  g728
-                                                  (g93 g730 g732 '(()))
-                                                  g729)))
-                                            g726)])
-                                        (g57 g730)
-                                        ((top-level-value 'map)
-                                          g199
-                                          g730))])
-                                    ((top-level-value 'map)
-                                      (top-level-value 'car)
-                                      g724)
-                                    ((top-level-value 'map)
-                                      (top-level-value 'cdr)
-                                      g724))])
-                               (case-lambda
-                                 [(g736 g737 g738 g739 g740 g741 g742 g743
-                                   g744)
-                                  ((top-level-value 'call-with-values)
-                                    (case-lambda [() (g649 g742 g737)])
-                                    (case-lambda
-                                      [(g745 g746)
-                                       (if ((top-level-value 'not)
-                                             (g116
-                                               ((top-level-value 'map)
-                                                 (top-level-value 'car)
-                                                 g746)))
-                                           (g117
-                                             ((top-level-value 'map)
-                                               (top-level-value 'car)
-                                               g746)
-                                             g742
-                                             '"pattern variable")
-                                           (if ((top-level-value 'not)
-                                                 ((top-level-value 'andmap)
-                                                   (case-lambda
-                                                     [(g747)
-                                                      ((top-level-value
-                                                         'not)
-                                                        (g195
-                                                          ((top-level-value
-                                                             'car)
-                                                            g747)))])
-                                                   g746))
-                                               ((top-level-value
-                                                  'syntax-error)
-                                                 g742
-                                                 '"misplaced ellipsis in syntax-case pattern")
-                                               ((case-lambda
-                                                  [(g748)
-                                                   ((top-level-value 'list)
-                                                     ((top-level-value
-                                                        'list)
-                                                       'case-lambda
-                                                       ((top-level-value
-                                                          'list)
-                                                         ((top-level-value
-                                                            'list)
-                                                           g748)
-                                                         ((top-level-value
-                                                            'list)
-                                                           'if
-                                                           ((case-lambda
-                                                              [(g749)
-                                                               ((case-lambda
-                                                                  [(g750)
-                                                                   (if g750
-                                                                       (#%apply
-                                                                         (case-lambda
-                                                                           [()
-                                                                            g748])
-                                                                         g750)
-                                                                       ((case-lambda
-                                                                          [(g751)
-                                                                           ((top-level-value
-                                                                              'list)
-                                                                             'if
-                                                                             g748
-                                                                             (g650
-                                                                               g746
-                                                                               g743
-                                                                               g748
-                                                                               g739
-                                                                               g740
-                                                                               g741)
-                                                                             ((top-level-value
-                                                                                'list)
-                                                                               'quote
-                                                                               '#f))])
-                                                                         g749))])
-                                                                 (#%$syntax-dispatch
-                                                                   g749
-                                                                   '#(atom
-                                                                      #t)))])
-                                                             g743)
-                                                           (g650 g746 g744
-                                                             g748 g739 g740
-                                                             g741)
-                                                           (g652 g736 g737
-                                                             g738 g739 g740
-                                                             g741))))
-                                                     (if ((top-level-value
-                                                            'eq?)
-                                                           g745
-                                                           'any)
-                                                         ((top-level-value
-                                                            'list)
-                                                           '#%list
-                                                           g736)
-                                                         ((top-level-value
-                                                            'list)
-                                                           '#%$syntax-dispatch
-                                                           g736
-                                                           ((top-level-value
-                                                              'list)
-                                                             'quote
-                                                             g745))))])
-                                                 (g199 'tmp))))]))])
-                               (case-lambda
-                                 [(g752 g753 g754 g755 g756 g757)
-                                  (if ((top-level-value 'null?) g754)
-                                      ((top-level-value 'list)
-                                        '#%syntax-error
-                                        g752)
-                                      ((case-lambda
-                                         [(g758)
-                                          ((case-lambda
-                                             [(g759)
-                                              (if g759
-                                                  (#%apply
-                                                    (case-lambda
-                                                      [(g760 g761)
-                                                       (if (if (g41 g760)
-                                                               (if ((top-level-value
-                                                                      'not)
-                                                                     (g118
-                                                                       g760
-                                                                       g753))
-                                                                   ((top-level-value
-                                                                      'not)
-                                                                     (g195
-                                                                       g760))
-                                                                   '#f)
-                                                               '#f)
-                                                           ((case-lambda
-                                                              [(g762 g763)
-                                                               ((top-level-value
-                                                                  'list)
-                                                                 ((top-level-value
-                                                                    'list)
-                                                                   'case-lambda
-                                                                   ((top-level-value
-                                                                      'list)
-                                                                     ((top-level-value
-                                                                        'list)
-                                                                       g763)
-                                                                     (g174
-                                                                       g761
-                                                                       (g30 g762
-                                                                            ((top-level-value
-                                                                               'cons)
-                                                                              'syntax
-                                                                              ((top-level-value
-                                                                                 'cons)
-                                                                                g763
-                                                                                '0))
-                                                                            g755)
-                                                                       g756
-                                                                       (g93 (#%list
-                                                                              g760)
-                                                                            ((top-level-value
-                                                                               'list)
-                                                                              g762)
-                                                                            '(()))
-                                                                       g757)))
-                                                                 g752)])
-                                                             (g55)
-                                                             (g199 g760))
-                                                           (g651 g752 g753
-                                                             ((top-level-value
-                                                                'cdr)
-                                                               g754)
-                                                             g755 g756 g757
-                                                             g760 '#t
-                                                             g761))])
-                                                    g759)
-                                                  ((case-lambda
-                                                     [(g764)
-                                                      (if g764
-                                                          (#%apply
-                                                            (case-lambda
-                                                              [(g765 g766
-                                                                g767)
-                                                               (g651 g752
-                                                                 g753
-                                                                 ((top-level-value
-                                                                    'cdr)
-                                                                   g754)
-                                                                 g755 g756
-                                                                 g757 g765
-                                                                 g766
-                                                                 g767)])
-                                                            g764)
-                                                          ((case-lambda
-                                                             [(g768)
-                                                              ((top-level-value
-                                                                 'syntax-error)
-                                                                ((top-level-value
-                                                                   'car)
-                                                                  g754)
-                                                                '"invalid syntax-case clause")])
-                                                            g758))])
-                                                    (#%$syntax-dispatch
-                                                      g758
-                                                      '(any any any))))])
-                                            (#%$syntax-dispatch
-                                              g758
-                                              '(any any)))])
-                                        ((top-level-value 'car)
-                                          g754)))]))])
-                           (void)
-                           (void)
-                           (void)
-                           (void))])))
-                (g12 'module
-                     (case-lambda
-                       [(g769)
-                        ((case-lambda
-                           [(g770)
-                            ((case-lambda
-                               [(g771)
-                                (begin
-                                  (set! g770 g771)
-                                  ((case-lambda
-                                     [(g772)
-                                      ((case-lambda
-                                         [(g773)
-                                          ((case-lambda
-                                             [(g774)
-                                              ((case-lambda
-                                                 [(g775)
-                                                  (if g775
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g776 g777 g778)
-                                                           (if ((top-level-value
-                                                                  'andmap)
-                                                                 g770
-                                                                 g777)
-                                                               (#%list
-                                                                 '#(syntax-object
-                                                                    begin
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          e
-                                                                          d)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(orig)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        (proper-export?)
-                                                                        ((top))
-                                                                        ("i"))
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        (lambda-var-list
-                                                                         gen-var
-                                                                         strip
-                                                                         strip*
-                                                                         strip-annotation
-                                                                         ellipsis?
-                                                                         chi-void
-                                                                         chi-local-syntax
-                                                                         chi-lambda-clause
-                                                                         parse-begin
-                                                                         parse-alias
-                                                                         parse-eval-when
-                                                                         parse-meta
-                                                                         parse-define-syntax
-                                                                         parse-define
-                                                                         parse-import
-                                                                         parse-module
-                                                                         do-import!
-                                                                         lookup-import-label
-                                                                         import-mark-delta
-                                                                         chi-internal
-                                                                         chi-body
-                                                                         chi-macro
-                                                                         chi-set!
-                                                                         chi-application
-                                                                         chi-expr
-                                                                         chi
-                                                                         chi-sequence
-                                                                         chi-meta-frob
-                                                                         chi-frobs
-                                                                         ct-eval/residualize3
-                                                                         ct-eval/residualize2
-                                                                         rt-eval/residualize
-                                                                         initial-mode-set
-                                                                         update-mode-set
-                                                                         do-top-import
-                                                                         vfor-each
-                                                                         vmap
-                                                                         chi-external
-                                                                         check-defined-ids
-                                                                         check-module-exports
-                                                                         id-set-diff
-                                                                         chi-top-module
-                                                                         set-frob-meta?!
-                                                                         set-frob-e!
-                                                                         frob-meta?
-                                                                         frob-e
-                                                                         frob?
-                                                                         make-frob
-                                                                         create-module-binding
-                                                                         set-module-binding-exported!
-                                                                         set-module-binding-val!
-                                                                         set-module-binding-imps!
-                                                                         set-module-binding-label!
-                                                                         set-module-binding-id!
-                                                                         set-module-binding-type!
-                                                                         module-binding-exported
-                                                                         module-binding-val
-                                                                         module-binding-imps
-                                                                         module-binding-label
-                                                                         module-binding-id
-                                                                         module-binding-type
-                                                                         module-binding?
-                                                                         make-module-binding
-                                                                         make-resolved-interface
-                                                                         make-unresolved-interface
-                                                                         set-interface-token!
-                                                                         set-interface-exports!
-                                                                         set-interface-marks!
-                                                                         interface-token
-                                                                         interface-exports
-                                                                         interface-marks
-                                                                         interface?
-                                                                         make-interface
-                                                                         flatten-exports
-                                                                         chi-top
-                                                                         chi-top-sequence
-                                                                         chi-top*
-                                                                         syntax-type
-                                                                         chi-when-list
-                                                                         source-wrap
-                                                                         wrap
-                                                                         bound-id-member?
-                                                                         invalid-ids-error
-                                                                         distinct-bound-ids?
-                                                                         valid-bound-ids?
-                                                                         bound-id=?
-                                                                         help-bound-id=?
-                                                                         literal-id=?
-                                                                         free-id=?
-                                                                         id-var-name
-                                                                         id-var-name-loc
-                                                                         id-var-name&marks
-                                                                         id-var-name-loc&marks
-                                                                         top-id-free-var-name
-                                                                         top-id-bound-var-name
-                                                                         anon
-                                                                         diff-marks
-                                                                         same-marks?
-                                                                         join-subst
-                                                                         join-marks
-                                                                         join-wraps
-                                                                         smart-append
-                                                                         resolved-id-var-name
-                                                                         id->resolved-id
-                                                                         make-resolved-id
-                                                                         make-binding-wrap
-                                                                         store-import-binding
-                                                                         lookup-import-binding-name
-                                                                         extend-ribcage-subst!
-                                                                         extend-ribcage-barrier-help!
-                                                                         extend-ribcage-barrier!
-                                                                         import-extend-ribcage!
-                                                                         extend-ribcage!
-                                                                         make-empty-ribcage
-                                                                         barrier-marker
-                                                                         new-mark
-                                                                         anti-mark
-                                                                         the-anti-mark
-                                                                         set-env-wrap!
-                                                                         set-env-top-ribcage!
-                                                                         env-wrap
-                                                                         env-top-ribcage
-                                                                         env?
-                                                                         make-env
-                                                                         set-import-interface-new-marks!
-                                                                         set-import-interface-interface!
-                                                                         import-interface-new-marks
-                                                                         import-interface-interface
-                                                                         import-interface?
-                                                                         make-import-interface
-                                                                         set-top-ribcage-mutable?!
-                                                                         set-top-ribcage-key!
-                                                                         top-ribcage-mutable?
-                                                                         top-ribcage-key
-                                                                         top-ribcage?
-                                                                         make-top-ribcage
-                                                                         set-ribcage-labels!
-                                                                         set-ribcage-marks!
-                                                                         set-ribcage-symnames!
-                                                                         ribcage-labels
-                                                                         ribcage-marks
-                                                                         ribcage-symnames
-                                                                         ribcage?
-                                                                         make-ribcage
-                                                                         gen-labels
-                                                                         label?
-                                                                         gen-label
-                                                                         set-indirect-label!
-                                                                         get-indirect-label
-                                                                         indirect-label?
-                                                                         gen-indirect-label
-                                                                         anon
-                                                                         only-top-marked?
-                                                                         top-marked?
-                                                                         top-wrap
-                                                                         empty-wrap
-                                                                         wrap-subst
-                                                                         wrap-marks
-                                                                         make-wrap
-                                                                         id-sym-name&marks
-                                                                         id-subst
-                                                                         id-marks
-                                                                         id-sym-name
-                                                                         id?
-                                                                         nonsymbol-id?
-                                                                         global-extend
-                                                                         defer-or-eval-transformer
-                                                                         make-transformer-binding
-                                                                         lookup
-                                                                         lookup*
-                                                                         displaced-lexical-error
-                                                                         displaced-lexical?
-                                                                         extend-var-env*
-                                                                         extend-env*
-                                                                         extend-env
-                                                                         null-env
-                                                                         binding?
-                                                                         set-binding-value!
-                                                                         set-binding-type!
-                                                                         binding-value
-                                                                         binding-type
-                                                                         make-binding
-                                                                         sanitize-binding
-                                                                         arg-check
-                                                                         no-source
-                                                                         unannotate
-                                                                         self-evaluating?
-                                                                         lexical-var?
-                                                                         build-lexical-var
-                                                                         build-top-module
-                                                                         build-body
-                                                                         build-letrec
-                                                                         build-sequence
-                                                                         build-data
-                                                                         build-primref
-                                                                         built-lambda?
-                                                                         build-lambda
-                                                                         build-revisit-only
-                                                                         build-visit-only
-                                                                         build-cte-install
-                                                                         build-global-definition
-                                                                         build-global-assignment
-                                                                         build-global-reference
-                                                                         build-lexical-assignment
-                                                                         build-lexical-reference
-                                                                         build-conditional
-                                                                         build-application
-                                                                         generate-id
-                                                                         put-import-binding
-                                                                         get-import-binding
-                                                                         read-only-binding?
-                                                                         put-global-definition-hook
-                                                                         get-global-definition-hook
-                                                                         put-cte-hook
-                                                                         gensym-hook
-                                                                         error-hook
-                                                                         define-top-level-value-hook
-                                                                         local-eval-hook
-                                                                         top-level-eval-hook
-                                                                         annotation?
-                                                                         set-syntax-object-wrap!
-                                                                         set-syntax-object-expression!
-                                                                         syntax-object-wrap
-                                                                         syntax-object-expression
-                                                                         syntax-object?
-                                                                         make-syntax-object
-                                                                         noexpand
-                                                                         let-values
-                                                                         define-structure
-                                                                         unless
-                                                                         when)
-                                                                        ((top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         ("m" top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         ("m" top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top))
-                                                                        ("i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 (#%cons
-                                                                   '#(syntax-object
-                                                                      $module
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            d)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(orig)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          (proper-export?)
-                                                                          ((top))
-                                                                          ("i"))
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          (lambda-var-list
-                                                                           gen-var
-                                                                           strip
-                                                                           strip*
-                                                                           strip-annotation
-                                                                           ellipsis?
-                                                                           chi-void
-                                                                           chi-local-syntax
-                                                                           chi-lambda-clause
-                                                                           parse-begin
-                                                                           parse-alias
-                                                                           parse-eval-when
-                                                                           parse-meta
-                                                                           parse-define-syntax
-                                                                           parse-define
-                                                                           parse-import
-                                                                           parse-module
-                                                                           do-import!
-                                                                           lookup-import-label
-                                                                           import-mark-delta
-                                                                           chi-internal
-                                                                           chi-body
-                                                                           chi-macro
-                                                                           chi-set!
-                                                                           chi-application
-                                                                           chi-expr
-                                                                           chi
-                                                                           chi-sequence
-                                                                           chi-meta-frob
-                                                                           chi-frobs
-                                                                           ct-eval/residualize3
-                                                                           ct-eval/residualize2
-                                                                           rt-eval/residualize
-                                                                           initial-mode-set
-                                                                           update-mode-set
-                                                                           do-top-import
-                                                                           vfor-each
-                                                                           vmap
-                                                                           chi-external
-                                                                           check-defined-ids
-                                                                           check-module-exports
-                                                                           id-set-diff
-                                                                           chi-top-module
-                                                                           set-frob-meta?!
-                                                                           set-frob-e!
-                                                                           frob-meta?
-                                                                           frob-e
-                                                                           frob?
-                                                                           make-frob
-                                                                           create-module-binding
-                                                                           set-module-binding-exported!
-                                                                           set-module-binding-val!
-                                                                           set-module-binding-imps!
-                                                                           set-module-binding-label!
-                                                                           set-module-binding-id!
-                                                                           set-module-binding-type!
-                                                                           module-binding-exported
-                                                                           module-binding-val
-                                                                           module-binding-imps
-                                                                           module-binding-label
-                                                                           module-binding-id
-                                                                           module-binding-type
-                                                                           module-binding?
-                                                                           make-module-binding
-                                                                           make-resolved-interface
-                                                                           make-unresolved-interface
-                                                                           set-interface-token!
-                                                                           set-interface-exports!
-                                                                           set-interface-marks!
-                                                                           interface-token
-                                                                           interface-exports
-                                                                           interface-marks
-                                                                           interface?
-                                                                           make-interface
-                                                                           flatten-exports
-                                                                           chi-top
-                                                                           chi-top-sequence
-                                                                           chi-top*
-                                                                           syntax-type
-                                                                           chi-when-list
-                                                                           source-wrap
-                                                                           wrap
-                                                                           bound-id-member?
-                                                                           invalid-ids-error
-                                                                           distinct-bound-ids?
-                                                                           valid-bound-ids?
-                                                                           bound-id=?
-                                                                           help-bound-id=?
-                                                                           literal-id=?
-                                                                           free-id=?
-                                                                           id-var-name
-                                                                           id-var-name-loc
-                                                                           id-var-name&marks
-                                                                           id-var-name-loc&marks
-                                                                           top-id-free-var-name
-                                                                           top-id-bound-var-name
-                                                                           anon
-                                                                           diff-marks
-                                                                           same-marks?
-                                                                           join-subst
-                                                                           join-marks
-                                                                           join-wraps
-                                                                           smart-append
-                                                                           resolved-id-var-name
-                                                                           id->resolved-id
-                                                                           make-resolved-id
-                                                                           make-binding-wrap
-                                                                           store-import-binding
-                                                                           lookup-import-binding-name
-                                                                           extend-ribcage-subst!
-                                                                           extend-ribcage-barrier-help!
-                                                                           extend-ribcage-barrier!
-                                                                           import-extend-ribcage!
-                                                                           extend-ribcage!
-                                                                           make-empty-ribcage
-                                                                           barrier-marker
-                                                                           new-mark
-                                                                           anti-mark
-                                                                           the-anti-mark
-                                                                           set-env-wrap!
-                                                                           set-env-top-ribcage!
-                                                                           env-wrap
-                                                                           env-top-ribcage
-                                                                           env?
-                                                                           make-env
-                                                                           set-import-interface-new-marks!
-                                                                           set-import-interface-interface!
-                                                                           import-interface-new-marks
-                                                                           import-interface-interface
-                                                                           import-interface?
-                                                                           make-import-interface
-                                                                           set-top-ribcage-mutable?!
-                                                                           set-top-ribcage-key!
-                                                                           top-ribcage-mutable?
-                                                                           top-ribcage-key
-                                                                           top-ribcage?
-                                                                           make-top-ribcage
-                                                                           set-ribcage-labels!
-                                                                           set-ribcage-marks!
-                                                                           set-ribcage-symnames!
-                                                                           ribcage-labels
-                                                                           ribcage-marks
-                                                                           ribcage-symnames
-                                                                           ribcage?
-                                                                           make-ribcage
-                                                                           gen-labels
-                                                                           label?
-                                                                           gen-label
-                                                                           set-indirect-label!
-                                                                           get-indirect-label
-                                                                           indirect-label?
-                                                                           gen-indirect-label
-                                                                           anon
-                                                                           only-top-marked?
-                                                                           top-marked?
-                                                                           top-wrap
-                                                                           empty-wrap
-                                                                           wrap-subst
-                                                                           wrap-marks
-                                                                           make-wrap
-                                                                           id-sym-name&marks
-                                                                           id-subst
-                                                                           id-marks
-                                                                           id-sym-name
-                                                                           id?
-                                                                           nonsymbol-id?
-                                                                           global-extend
-                                                                           defer-or-eval-transformer
-                                                                           make-transformer-binding
-                                                                           lookup
-                                                                           lookup*
-                                                                           displaced-lexical-error
-                                                                           displaced-lexical?
-                                                                           extend-var-env*
-                                                                           extend-env*
-                                                                           extend-env
-                                                                           null-env
-                                                                           binding?
-                                                                           set-binding-value!
-                                                                           set-binding-type!
-                                                                           binding-value
-                                                                           binding-type
-                                                                           make-binding
-                                                                           sanitize-binding
-                                                                           arg-check
-                                                                           no-source
-                                                                           unannotate
-                                                                           self-evaluating?
-                                                                           lexical-var?
-                                                                           build-lexical-var
-                                                                           build-top-module
-                                                                           build-body
-                                                                           build-letrec
-                                                                           build-sequence
-                                                                           build-data
-                                                                           build-primref
-                                                                           built-lambda?
-                                                                           build-lambda
-                                                                           build-revisit-only
-                                                                           build-visit-only
-                                                                           build-cte-install
-                                                                           build-global-definition
-                                                                           build-global-assignment
-                                                                           build-global-reference
-                                                                           build-lexical-assignment
-                                                                           build-lexical-reference
-                                                                           build-conditional
-                                                                           build-application
-                                                                           generate-id
-                                                                           put-import-binding
-                                                                           get-import-binding
-                                                                           read-only-binding?
-                                                                           put-global-definition-hook
-                                                                           get-global-definition-hook
-                                                                           put-cte-hook
-                                                                           gensym-hook
-                                                                           error-hook
-                                                                           define-top-level-value-hook
-                                                                           local-eval-hook
-                                                                           top-level-eval-hook
-                                                                           annotation?
-                                                                           set-syntax-object-wrap!
-                                                                           set-syntax-object-expression!
-                                                                           syntax-object-wrap
-                                                                           syntax-object-expression
-                                                                           syntax-object?
-                                                                           make-syntax-object
-                                                                           noexpand
-                                                                           let-values
-                                                                           define-structure
-                                                                           unless
-                                                                           when)
-                                                                          ((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           ("m" top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           ("m" top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                          ("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%cons
-                                                                     g773
-                                                                     (#%cons
-                                                                       '#(syntax-object
-                                                                          anon
-                                                                          ((top)
-                                                                            #(ribcage
-                                                                              #(_
-                                                                                e
-                                                                                d)
-                                                                              #((top)
-                                                                                (top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              #(orig)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              (proper-export?)
-                                                                              ((top))
-                                                                              ("i"))
-                                                                            #(ribcage
-                                                                              #(x)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              (lambda-var-list
-                                                                               gen-var
-                                                                               strip
-                                                                               strip*
-                                                                               strip-annotation
-                                                                               ellipsis?
-                                                                               chi-void
-                                                                               chi-local-syntax
-                                                                               chi-lambda-clause
-                                                                               parse-begin
-                                                                               parse-alias
-                                                                               parse-eval-when
-                                                                               parse-meta
-                                                                               parse-define-syntax
-                                                                               parse-define
-                                                                               parse-import
-                                                                               parse-module
-                                                                               do-import!
-                                                                               lookup-import-label
-                                                                               import-mark-delta
-                                                                               chi-internal
-                                                                               chi-body
-                                                                               chi-macro
-                                                                               chi-set!
-                                                                               chi-application
-                                                                               chi-expr
-                                                                               chi
-                                                                               chi-sequence
-                                                                               chi-meta-frob
-                                                                               chi-frobs
-                                                                               ct-eval/residualize3
-                                                                               ct-eval/residualize2
-                                                                               rt-eval/residualize
-                                                                               initial-mode-set
-                                                                               update-mode-set
-                                                                               do-top-import
-                                                                               vfor-each
-                                                                               vmap
-                                                                               chi-external
-                                                                               check-defined-ids
-                                                                               check-module-exports
-                                                                               id-set-diff
-                                                                               chi-top-module
-                                                                               set-frob-meta?!
-                                                                               set-frob-e!
-                                                                               frob-meta?
-                                                                               frob-e
-                                                                               frob?
-                                                                               make-frob
-                                                                               create-module-binding
-                                                                               set-module-binding-exported!
-                                                                               set-module-binding-val!
-                                                                               set-module-binding-imps!
-                                                                               set-module-binding-label!
-                                                                               set-module-binding-id!
-                                                                               set-module-binding-type!
-                                                                               module-binding-exported
-                                                                               module-binding-val
-                                                                               module-binding-imps
-                                                                               module-binding-label
-                                                                               module-binding-id
-                                                                               module-binding-type
-                                                                               module-binding?
-                                                                               make-module-binding
-                                                                               make-resolved-interface
-                                                                               make-unresolved-interface
-                                                                               set-interface-token!
-                                                                               set-interface-exports!
-                                                                               set-interface-marks!
-                                                                               interface-token
-                                                                               interface-exports
-                                                                               interface-marks
-                                                                               interface?
-                                                                               make-interface
-                                                                               flatten-exports
-                                                                               chi-top
-                                                                               chi-top-sequence
-                                                                               chi-top*
-                                                                               syntax-type
-                                                                               chi-when-list
-                                                                               source-wrap
-                                                                               wrap
-                                                                               bound-id-member?
-                                                                               invalid-ids-error
-                                                                               distinct-bound-ids?
-                                                                               valid-bound-ids?
-                                                                               bound-id=?
-                                                                               help-bound-id=?
-                                                                               literal-id=?
-                                                                               free-id=?
-                                                                               id-var-name
-                                                                               id-var-name-loc
-                                                                               id-var-name&marks
-                                                                               id-var-name-loc&marks
-                                                                               top-id-free-var-name
-                                                                               top-id-bound-var-name
-                                                                               anon
-                                                                               diff-marks
-                                                                               same-marks?
-                                                                               join-subst
-                                                                               join-marks
-                                                                               join-wraps
-                                                                               smart-append
-                                                                               resolved-id-var-name
-                                                                               id->resolved-id
-                                                                               make-resolved-id
-                                                                               make-binding-wrap
-                                                                               store-import-binding
-                                                                               lookup-import-binding-name
-                                                                               extend-ribcage-subst!
-                                                                               extend-ribcage-barrier-help!
-                                                                               extend-ribcage-barrier!
-                                                                               import-extend-ribcage!
-                                                                               extend-ribcage!
-                                                                               make-empty-ribcage
-                                                                               barrier-marker
-                                                                               new-mark
-                                                                               anti-mark
-                                                                               the-anti-mark
-                                                                               set-env-wrap!
-                                                                               set-env-top-ribcage!
-                                                                               env-wrap
-                                                                               env-top-ribcage
-                                                                               env?
-                                                                               make-env
-                                                                               set-import-interface-new-marks!
-                                                                               set-import-interface-interface!
-                                                                               import-interface-new-marks
-                                                                               import-interface-interface
-                                                                               import-interface?
-                                                                               make-import-interface
-                                                                               set-top-ribcage-mutable?!
-                                                                               set-top-ribcage-key!
-                                                                               top-ribcage-mutable?
-                                                                               top-ribcage-key
-                                                                               top-ribcage?
-                                                                               make-top-ribcage
-                                                                               set-ribcage-labels!
-                                                                               set-ribcage-marks!
-                                                                               set-ribcage-symnames!
-                                                                               ribcage-labels
-                                                                               ribcage-marks
-                                                                               ribcage-symnames
-                                                                               ribcage?
-                                                                               make-ribcage
-                                                                               gen-labels
-                                                                               label?
-                                                                               gen-label
-                                                                               set-indirect-label!
-                                                                               get-indirect-label
-                                                                               indirect-label?
-                                                                               gen-indirect-label
-                                                                               anon
-                                                                               only-top-marked?
-                                                                               top-marked?
-                                                                               top-wrap
-                                                                               empty-wrap
-                                                                               wrap-subst
-                                                                               wrap-marks
-                                                                               make-wrap
-                                                                               id-sym-name&marks
-                                                                               id-subst
-                                                                               id-marks
-                                                                               id-sym-name
-                                                                               id?
-                                                                               nonsymbol-id?
-                                                                               global-extend
-                                                                               defer-or-eval-transformer
-                                                                               make-transformer-binding
-                                                                               lookup
-                                                                               lookup*
-                                                                               displaced-lexical-error
-                                                                               displaced-lexical?
-                                                                               extend-var-env*
-                                                                               extend-env*
-                                                                               extend-env
-                                                                               null-env
-                                                                               binding?
-                                                                               set-binding-value!
-                                                                               set-binding-type!
-                                                                               binding-value
-                                                                               binding-type
-                                                                               make-binding
-                                                                               sanitize-binding
-                                                                               arg-check
-                                                                               no-source
-                                                                               unannotate
-                                                                               self-evaluating?
-                                                                               lexical-var?
-                                                                               build-lexical-var
-                                                                               build-top-module
-                                                                               build-body
-                                                                               build-letrec
-                                                                               build-sequence
-                                                                               build-data
-                                                                               build-primref
-                                                                               built-lambda?
-                                                                               build-lambda
-                                                                               build-revisit-only
-                                                                               build-visit-only
-                                                                               build-cte-install
-                                                                               build-global-definition
-                                                                               build-global-assignment
-                                                                               build-global-reference
-                                                                               build-lexical-assignment
-                                                                               build-lexical-reference
-                                                                               build-conditional
-                                                                               build-application
-                                                                               generate-id
-                                                                               put-import-binding
-                                                                               get-import-binding
-                                                                               read-only-binding?
-                                                                               put-global-definition-hook
-                                                                               get-global-definition-hook
-                                                                               put-cte-hook
-                                                                               gensym-hook
-                                                                               error-hook
-                                                                               define-top-level-value-hook
-                                                                               local-eval-hook
-                                                                               top-level-eval-hook
-                                                                               annotation?
-                                                                               set-syntax-object-wrap!
-                                                                               set-syntax-object-expression!
-                                                                               syntax-object-wrap
-                                                                               syntax-object-expression
-                                                                               syntax-object?
-                                                                               make-syntax-object
-                                                                               noexpand
-                                                                               let-values
-                                                                               define-structure
-                                                                               unless
-                                                                               when)
-                                                                              ((top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               ("m" top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               ("m" top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top))
-                                                                              ("i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"))
-                                                                            #(top-ribcage
-                                                                              *top*
-                                                                              #t)))
-                                                                       (#%cons
-                                                                         g777
-                                                                         g778))))
-                                                                 (#%cons
-                                                                   '#(syntax-object
-                                                                      $import
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            d)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(orig)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          (proper-export?)
-                                                                          ((top))
-                                                                          ("i"))
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          (lambda-var-list
-                                                                           gen-var
-                                                                           strip
-                                                                           strip*
-                                                                           strip-annotation
-                                                                           ellipsis?
-                                                                           chi-void
-                                                                           chi-local-syntax
-                                                                           chi-lambda-clause
-                                                                           parse-begin
-                                                                           parse-alias
-                                                                           parse-eval-when
-                                                                           parse-meta
-                                                                           parse-define-syntax
-                                                                           parse-define
-                                                                           parse-import
-                                                                           parse-module
-                                                                           do-import!
-                                                                           lookup-import-label
-                                                                           import-mark-delta
-                                                                           chi-internal
-                                                                           chi-body
-                                                                           chi-macro
-                                                                           chi-set!
-                                                                           chi-application
-                                                                           chi-expr
-                                                                           chi
-                                                                           chi-sequence
-                                                                           chi-meta-frob
-                                                                           chi-frobs
-                                                                           ct-eval/residualize3
-                                                                           ct-eval/residualize2
-                                                                           rt-eval/residualize
-                                                                           initial-mode-set
-                                                                           update-mode-set
-                                                                           do-top-import
-                                                                           vfor-each
-                                                                           vmap
-                                                                           chi-external
-                                                                           check-defined-ids
-                                                                           check-module-exports
-                                                                           id-set-diff
-                                                                           chi-top-module
-                                                                           set-frob-meta?!
-                                                                           set-frob-e!
-                                                                           frob-meta?
-                                                                           frob-e
-                                                                           frob?
-                                                                           make-frob
-                                                                           create-module-binding
-                                                                           set-module-binding-exported!
-                                                                           set-module-binding-val!
-                                                                           set-module-binding-imps!
-                                                                           set-module-binding-label!
-                                                                           set-module-binding-id!
-                                                                           set-module-binding-type!
-                                                                           module-binding-exported
-                                                                           module-binding-val
-                                                                           module-binding-imps
-                                                                           module-binding-label
-                                                                           module-binding-id
-                                                                           module-binding-type
-                                                                           module-binding?
-                                                                           make-module-binding
-                                                                           make-resolved-interface
-                                                                           make-unresolved-interface
-                                                                           set-interface-token!
-                                                                           set-interface-exports!
-                                                                           set-interface-marks!
-                                                                           interface-token
-                                                                           interface-exports
-                                                                           interface-marks
-                                                                           interface?
-                                                                           make-interface
-                                                                           flatten-exports
-                                                                           chi-top
-                                                                           chi-top-sequence
-                                                                           chi-top*
-                                                                           syntax-type
-                                                                           chi-when-list
-                                                                           source-wrap
-                                                                           wrap
-                                                                           bound-id-member?
-                                                                           invalid-ids-error
-                                                                           distinct-bound-ids?
-                                                                           valid-bound-ids?
-                                                                           bound-id=?
-                                                                           help-bound-id=?
-                                                                           literal-id=?
-                                                                           free-id=?
-                                                                           id-var-name
-                                                                           id-var-name-loc
-                                                                           id-var-name&marks
-                                                                           id-var-name-loc&marks
-                                                                           top-id-free-var-name
-                                                                           top-id-bound-var-name
-                                                                           anon
-                                                                           diff-marks
-                                                                           same-marks?
-                                                                           join-subst
-                                                                           join-marks
-                                                                           join-wraps
-                                                                           smart-append
-                                                                           resolved-id-var-name
-                                                                           id->resolved-id
-                                                                           make-resolved-id
-                                                                           make-binding-wrap
-                                                                           store-import-binding
-                                                                           lookup-import-binding-name
-                                                                           extend-ribcage-subst!
-                                                                           extend-ribcage-barrier-help!
-                                                                           extend-ribcage-barrier!
-                                                                           import-extend-ribcage!
-                                                                           extend-ribcage!
-                                                                           make-empty-ribcage
-                                                                           barrier-marker
-                                                                           new-mark
-                                                                           anti-mark
-                                                                           the-anti-mark
-                                                                           set-env-wrap!
-                                                                           set-env-top-ribcage!
-                                                                           env-wrap
-                                                                           env-top-ribcage
-                                                                           env?
-                                                                           make-env
-                                                                           set-import-interface-new-marks!
-                                                                           set-import-interface-interface!
-                                                                           import-interface-new-marks
-                                                                           import-interface-interface
-                                                                           import-interface?
-                                                                           make-import-interface
-                                                                           set-top-ribcage-mutable?!
-                                                                           set-top-ribcage-key!
-                                                                           top-ribcage-mutable?
-                                                                           top-ribcage-key
-                                                                           top-ribcage?
-                                                                           make-top-ribcage
-                                                                           set-ribcage-labels!
-                                                                           set-ribcage-marks!
-                                                                           set-ribcage-symnames!
-                                                                           ribcage-labels
-                                                                           ribcage-marks
-                                                                           ribcage-symnames
-                                                                           ribcage?
-                                                                           make-ribcage
-                                                                           gen-labels
-                                                                           label?
-                                                                           gen-label
-                                                                           set-indirect-label!
-                                                                           get-indirect-label
-                                                                           indirect-label?
-                                                                           gen-indirect-label
-                                                                           anon
-                                                                           only-top-marked?
-                                                                           top-marked?
-                                                                           top-wrap
-                                                                           empty-wrap
-                                                                           wrap-subst
-                                                                           wrap-marks
-                                                                           make-wrap
-                                                                           id-sym-name&marks
-                                                                           id-subst
-                                                                           id-marks
-                                                                           id-sym-name
-                                                                           id?
-                                                                           nonsymbol-id?
-                                                                           global-extend
-                                                                           defer-or-eval-transformer
-                                                                           make-transformer-binding
-                                                                           lookup
-                                                                           lookup*
-                                                                           displaced-lexical-error
-                                                                           displaced-lexical?
-                                                                           extend-var-env*
-                                                                           extend-env*
-                                                                           extend-env
-                                                                           null-env
-                                                                           binding?
-                                                                           set-binding-value!
-                                                                           set-binding-type!
-                                                                           binding-value
-                                                                           binding-type
-                                                                           make-binding
-                                                                           sanitize-binding
-                                                                           arg-check
-                                                                           no-source
-                                                                           unannotate
-                                                                           self-evaluating?
-                                                                           lexical-var?
-                                                                           build-lexical-var
-                                                                           build-top-module
-                                                                           build-body
-                                                                           build-letrec
-                                                                           build-sequence
-                                                                           build-data
-                                                                           build-primref
-                                                                           built-lambda?
-                                                                           build-lambda
-                                                                           build-revisit-only
-                                                                           build-visit-only
-                                                                           build-cte-install
-                                                                           build-global-definition
-                                                                           build-global-assignment
-                                                                           build-global-reference
-                                                                           build-lexical-assignment
-                                                                           build-lexical-reference
-                                                                           build-conditional
-                                                                           build-application
-                                                                           generate-id
-                                                                           put-import-binding
-                                                                           get-import-binding
-                                                                           read-only-binding?
-                                                                           put-global-definition-hook
-                                                                           get-global-definition-hook
-                                                                           put-cte-hook
-                                                                           gensym-hook
-                                                                           error-hook
-                                                                           define-top-level-value-hook
-                                                                           local-eval-hook
-                                                                           top-level-eval-hook
-                                                                           annotation?
-                                                                           set-syntax-object-wrap!
-                                                                           set-syntax-object-expression!
-                                                                           syntax-object-wrap
-                                                                           syntax-object-expression
-                                                                           syntax-object?
-                                                                           make-syntax-object
-                                                                           noexpand
-                                                                           let-values
-                                                                           define-structure
-                                                                           unless
-                                                                           when)
-                                                                          ((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           ("m" top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           ("m" top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                          ("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%cons
-                                                                     g773
-                                                                     '#(syntax-object
-                                                                        (#f anon)
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(_
-                                                                              e
-                                                                              d)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(orig)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            (proper-export?)
-                                                                            ((top))
-                                                                            ("i"))
-                                                                          #(ribcage
-                                                                            #(x)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            (lambda-var-list
-                                                                             gen-var
-                                                                             strip
-                                                                             strip*
-                                                                             strip-annotation
-                                                                             ellipsis?
-                                                                             chi-void
-                                                                             chi-local-syntax
-                                                                             chi-lambda-clause
-                                                                             parse-begin
-                                                                             parse-alias
-                                                                             parse-eval-when
-                                                                             parse-meta
-                                                                             parse-define-syntax
-                                                                             parse-define
-                                                                             parse-import
-                                                                             parse-module
-                                                                             do-import!
-                                                                             lookup-import-label
-                                                                             import-mark-delta
-                                                                             chi-internal
-                                                                             chi-body
-                                                                             chi-macro
-                                                                             chi-set!
-                                                                             chi-application
-                                                                             chi-expr
-                                                                             chi
-                                                                             chi-sequence
-                                                                             chi-meta-frob
-                                                                             chi-frobs
-                                                                             ct-eval/residualize3
-                                                                             ct-eval/residualize2
-                                                                             rt-eval/residualize
-                                                                             initial-mode-set
-                                                                             update-mode-set
-                                                                             do-top-import
-                                                                             vfor-each
-                                                                             vmap
-                                                                             chi-external
-                                                                             check-defined-ids
-                                                                             check-module-exports
-                                                                             id-set-diff
-                                                                             chi-top-module
-                                                                             set-frob-meta?!
-                                                                             set-frob-e!
-                                                                             frob-meta?
-                                                                             frob-e
-                                                                             frob?
-                                                                             make-frob
-                                                                             create-module-binding
-                                                                             set-module-binding-exported!
-                                                                             set-module-binding-val!
-                                                                             set-module-binding-imps!
-                                                                             set-module-binding-label!
-                                                                             set-module-binding-id!
-                                                                             set-module-binding-type!
-                                                                             module-binding-exported
-                                                                             module-binding-val
-                                                                             module-binding-imps
-                                                                             module-binding-label
-                                                                             module-binding-id
-                                                                             module-binding-type
-                                                                             module-binding?
-                                                                             make-module-binding
-                                                                             make-resolved-interface
-                                                                             make-unresolved-interface
-                                                                             set-interface-token!
-                                                                             set-interface-exports!
-                                                                             set-interface-marks!
-                                                                             interface-token
-                                                                             interface-exports
-                                                                             interface-marks
-                                                                             interface?
-                                                                             make-interface
-                                                                             flatten-exports
-                                                                             chi-top
-                                                                             chi-top-sequence
-                                                                             chi-top*
-                                                                             syntax-type
-                                                                             chi-when-list
-                                                                             source-wrap
-                                                                             wrap
-                                                                             bound-id-member?
-                                                                             invalid-ids-error
-                                                                             distinct-bound-ids?
-                                                                             valid-bound-ids?
-                                                                             bound-id=?
-                                                                             help-bound-id=?
-                                                                             literal-id=?
-                                                                             free-id=?
-                                                                             id-var-name
-                                                                             id-var-name-loc
-                                                                             id-var-name&marks
-                                                                             id-var-name-loc&marks
-                                                                             top-id-free-var-name
-                                                                             top-id-bound-var-name
-                                                                             anon
-                                                                             diff-marks
-                                                                             same-marks?
-                                                                             join-subst
-                                                                             join-marks
-                                                                             join-wraps
-                                                                             smart-append
-                                                                             resolved-id-var-name
-                                                                             id->resolved-id
-                                                                             make-resolved-id
-                                                                             make-binding-wrap
-                                                                             store-import-binding
-                                                                             lookup-import-binding-name
-                                                                             extend-ribcage-subst!
-                                                                             extend-ribcage-barrier-help!
-                                                                             extend-ribcage-barrier!
-                                                                             import-extend-ribcage!
-                                                                             extend-ribcage!
-                                                                             make-empty-ribcage
-                                                                             barrier-marker
-                                                                             new-mark
-                                                                             anti-mark
-                                                                             the-anti-mark
-                                                                             set-env-wrap!
-                                                                             set-env-top-ribcage!
-                                                                             env-wrap
-                                                                             env-top-ribcage
-                                                                             env?
-                                                                             make-env
-                                                                             set-import-interface-new-marks!
-                                                                             set-import-interface-interface!
-                                                                             import-interface-new-marks
-                                                                             import-interface-interface
-                                                                             import-interface?
-                                                                             make-import-interface
-                                                                             set-top-ribcage-mutable?!
-                                                                             set-top-ribcage-key!
-                                                                             top-ribcage-mutable?
-                                                                             top-ribcage-key
-                                                                             top-ribcage?
-                                                                             make-top-ribcage
-                                                                             set-ribcage-labels!
-                                                                             set-ribcage-marks!
-                                                                             set-ribcage-symnames!
-                                                                             ribcage-labels
-                                                                             ribcage-marks
-                                                                             ribcage-symnames
-                                                                             ribcage?
-                                                                             make-ribcage
-                                                                             gen-labels
-                                                                             label?
-                                                                             gen-label
-                                                                             set-indirect-label!
-                                                                             get-indirect-label
-                                                                             indirect-label?
-                                                                             gen-indirect-label
-                                                                             anon
-                                                                             only-top-marked?
-                                                                             top-marked?
-                                                                             top-wrap
-                                                                             empty-wrap
-                                                                             wrap-subst
-                                                                             wrap-marks
-                                                                             make-wrap
-                                                                             id-sym-name&marks
-                                                                             id-subst
-                                                                             id-marks
-                                                                             id-sym-name
-                                                                             id?
-                                                                             nonsymbol-id?
-                                                                             global-extend
-                                                                             defer-or-eval-transformer
-                                                                             make-transformer-binding
-                                                                             lookup
-                                                                             lookup*
-                                                                             displaced-lexical-error
-                                                                             displaced-lexical?
-                                                                             extend-var-env*
-                                                                             extend-env*
-                                                                             extend-env
-                                                                             null-env
-                                                                             binding?
-                                                                             set-binding-value!
-                                                                             set-binding-type!
-                                                                             binding-value
-                                                                             binding-type
-                                                                             make-binding
-                                                                             sanitize-binding
-                                                                             arg-check
-                                                                             no-source
-                                                                             unannotate
-                                                                             self-evaluating?
-                                                                             lexical-var?
-                                                                             build-lexical-var
-                                                                             build-top-module
-                                                                             build-body
-                                                                             build-letrec
-                                                                             build-sequence
-                                                                             build-data
-                                                                             build-primref
-                                                                             built-lambda?
-                                                                             build-lambda
-                                                                             build-revisit-only
-                                                                             build-visit-only
-                                                                             build-cte-install
-                                                                             build-global-definition
-                                                                             build-global-assignment
-                                                                             build-global-reference
-                                                                             build-lexical-assignment
-                                                                             build-lexical-reference
-                                                                             build-conditional
-                                                                             build-application
-                                                                             generate-id
-                                                                             put-import-binding
-                                                                             get-import-binding
-                                                                             read-only-binding?
-                                                                             put-global-definition-hook
-                                                                             get-global-definition-hook
-                                                                             put-cte-hook
-                                                                             gensym-hook
-                                                                             error-hook
-                                                                             define-top-level-value-hook
-                                                                             local-eval-hook
-                                                                             top-level-eval-hook
-                                                                             annotation?
-                                                                             set-syntax-object-wrap!
-                                                                             set-syntax-object-expression!
-                                                                             syntax-object-wrap
-                                                                             syntax-object-expression
-                                                                             syntax-object?
-                                                                             make-syntax-object
-                                                                             noexpand
-                                                                             let-values
-                                                                             define-structure
-                                                                             unless
-                                                                             when)
-                                                                            ((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             ("m" top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             ("m" top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                            ("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t))))))
-                                                               ((top-level-value
-                                                                  'syntax-error)
-                                                                 g769
-                                                                 '"invalid exports list in"))])
-                                                        g775)
-                                                      ((case-lambda
-                                                         [(g779)
-                                                          (if (if g779
-                                                                  (#%apply
-                                                                    (case-lambda
-                                                                      [(g780
-                                                                        g781
-                                                                        g782
-                                                                        g783)
-                                                                       ((top-level-value
-                                                                          'identifier?)
-                                                                         g781)])
-                                                                    g779)
-                                                                  '#f)
-                                                              (#%apply
-                                                                (case-lambda
-                                                                  [(g784
-                                                                    g785
-                                                                    g786
-                                                                    g787)
-                                                                   (if ((top-level-value
-                                                                          'andmap)
-                                                                         g770
-                                                                         g786)
-                                                                       (#%cons
-                                                                         '#(syntax-object
-                                                                            $module
-                                                                            ((top)
-                                                                              #(ribcage
-                                                                                #(_
-                                                                                  m
-                                                                                  e
-                                                                                  d)
-                                                                                #((top)
-                                                                                  (top)
-                                                                                  (top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"
-                                                                                  "i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(orig)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                (proper-export?)
-                                                                                ((top))
-                                                                                ("i"))
-                                                                              #(ribcage
-                                                                                #(x)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                (lambda-var-list
-                                                                                 gen-var
-                                                                                 strip
-                                                                                 strip*
-                                                                                 strip-annotation
-                                                                                 ellipsis?
-                                                                                 chi-void
-                                                                                 chi-local-syntax
-                                                                                 chi-lambda-clause
-                                                                                 parse-begin
-                                                                                 parse-alias
-                                                                                 parse-eval-when
-                                                                                 parse-meta
-                                                                                 parse-define-syntax
-                                                                                 parse-define
-                                                                                 parse-import
-                                                                                 parse-module
-                                                                                 do-import!
-                                                                                 lookup-import-label
-                                                                                 import-mark-delta
-                                                                                 chi-internal
-                                                                                 chi-body
-                                                                                 chi-macro
-                                                                                 chi-set!
-                                                                                 chi-application
-                                                                                 chi-expr
-                                                                                 chi
-                                                                                 chi-sequence
-                                                                                 chi-meta-frob
-                                                                                 chi-frobs
-                                                                                 ct-eval/residualize3
-                                                                                 ct-eval/residualize2
-                                                                                 rt-eval/residualize
-                                                                                 initial-mode-set
-                                                                                 update-mode-set
-                                                                                 do-top-import
-                                                                                 vfor-each
-                                                                                 vmap
-                                                                                 chi-external
-                                                                                 check-defined-ids
-                                                                                 check-module-exports
-                                                                                 id-set-diff
-                                                                                 chi-top-module
-                                                                                 set-frob-meta?!
-                                                                                 set-frob-e!
-                                                                                 frob-meta?
-                                                                                 frob-e
-                                                                                 frob?
-                                                                                 make-frob
-                                                                                 create-module-binding
-                                                                                 set-module-binding-exported!
-                                                                                 set-module-binding-val!
-                                                                                 set-module-binding-imps!
-                                                                                 set-module-binding-label!
-                                                                                 set-module-binding-id!
-                                                                                 set-module-binding-type!
-                                                                                 module-binding-exported
-                                                                                 module-binding-val
-                                                                                 module-binding-imps
-                                                                                 module-binding-label
-                                                                                 module-binding-id
-                                                                                 module-binding-type
-                                                                                 module-binding?
-                                                                                 make-module-binding
-                                                                                 make-resolved-interface
-                                                                                 make-unresolved-interface
-                                                                                 set-interface-token!
-                                                                                 set-interface-exports!
-                                                                                 set-interface-marks!
-                                                                                 interface-token
-                                                                                 interface-exports
-                                                                                 interface-marks
-                                                                                 interface?
-                                                                                 make-interface
-                                                                                 flatten-exports
-                                                                                 chi-top
-                                                                                 chi-top-sequence
-                                                                                 chi-top*
-                                                                                 syntax-type
-                                                                                 chi-when-list
-                                                                                 source-wrap
-                                                                                 wrap
-                                                                                 bound-id-member?
-                                                                                 invalid-ids-error
-                                                                                 distinct-bound-ids?
-                                                                                 valid-bound-ids?
-                                                                                 bound-id=?
-                                                                                 help-bound-id=?
-                                                                                 literal-id=?
-                                                                                 free-id=?
-                                                                                 id-var-name
-                                                                                 id-var-name-loc
-                                                                                 id-var-name&marks
-                                                                                 id-var-name-loc&marks
-                                                                                 top-id-free-var-name
-                                                                                 top-id-bound-var-name
-                                                                                 anon
-                                                                                 diff-marks
-                                                                                 same-marks?
-                                                                                 join-subst
-                                                                                 join-marks
-                                                                                 join-wraps
-                                                                                 smart-append
-                                                                                 resolved-id-var-name
-                                                                                 id->resolved-id
-                                                                                 make-resolved-id
-                                                                                 make-binding-wrap
-                                                                                 store-import-binding
-                                                                                 lookup-import-binding-name
-                                                                                 extend-ribcage-subst!
-                                                                                 extend-ribcage-barrier-help!
-                                                                                 extend-ribcage-barrier!
-                                                                                 import-extend-ribcage!
-                                                                                 extend-ribcage!
-                                                                                 make-empty-ribcage
-                                                                                 barrier-marker
-                                                                                 new-mark
-                                                                                 anti-mark
-                                                                                 the-anti-mark
-                                                                                 set-env-wrap!
-                                                                                 set-env-top-ribcage!
-                                                                                 env-wrap
-                                                                                 env-top-ribcage
-                                                                                 env?
-                                                                                 make-env
-                                                                                 set-import-interface-new-marks!
-                                                                                 set-import-interface-interface!
-                                                                                 import-interface-new-marks
-                                                                                 import-interface-interface
-                                                                                 import-interface?
-                                                                                 make-import-interface
-                                                                                 set-top-ribcage-mutable?!
-                                                                                 set-top-ribcage-key!
-                                                                                 top-ribcage-mutable?
-                                                                                 top-ribcage-key
-                                                                                 top-ribcage?
-                                                                                 make-top-ribcage
-                                                                                 set-ribcage-labels!
-                                                                                 set-ribcage-marks!
-                                                                                 set-ribcage-symnames!
-                                                                                 ribcage-labels
-                                                                                 ribcage-marks
-                                                                                 ribcage-symnames
-                                                                                 ribcage?
-                                                                                 make-ribcage
-                                                                                 gen-labels
-                                                                                 label?
-                                                                                 gen-label
-                                                                                 set-indirect-label!
-                                                                                 get-indirect-label
-                                                                                 indirect-label?
-                                                                                 gen-indirect-label
-                                                                                 anon
-                                                                                 only-top-marked?
-                                                                                 top-marked?
-                                                                                 top-wrap
-                                                                                 empty-wrap
-                                                                                 wrap-subst
-                                                                                 wrap-marks
-                                                                                 make-wrap
-                                                                                 id-sym-name&marks
-                                                                                 id-subst
-                                                                                 id-marks
-                                                                                 id-sym-name
-                                                                                 id?
-                                                                                 nonsymbol-id?
-                                                                                 global-extend
-                                                                                 defer-or-eval-transformer
-                                                                                 make-transformer-binding
-                                                                                 lookup
-                                                                                 lookup*
-                                                                                 displaced-lexical-error
-                                                                                 displaced-lexical?
-                                                                                 extend-var-env*
-                                                                                 extend-env*
-                                                                                 extend-env
-                                                                                 null-env
-                                                                                 binding?
-                                                                                 set-binding-value!
-                                                                                 set-binding-type!
-                                                                                 binding-value
-                                                                                 binding-type
-                                                                                 make-binding
-                                                                                 sanitize-binding
-                                                                                 arg-check
-                                                                                 no-source
-                                                                                 unannotate
-                                                                                 self-evaluating?
-                                                                                 lexical-var?
-                                                                                 build-lexical-var
-                                                                                 build-top-module
-                                                                                 build-body
-                                                                                 build-letrec
-                                                                                 build-sequence
-                                                                                 build-data
-                                                                                 build-primref
-                                                                                 built-lambda?
-                                                                                 build-lambda
-                                                                                 build-revisit-only
-                                                                                 build-visit-only
-                                                                                 build-cte-install
-                                                                                 build-global-definition
-                                                                                 build-global-assignment
-                                                                                 build-global-reference
-                                                                                 build-lexical-assignment
-                                                                                 build-lexical-reference
-                                                                                 build-conditional
-                                                                                 build-application
-                                                                                 generate-id
-                                                                                 put-import-binding
-                                                                                 get-import-binding
-                                                                                 read-only-binding?
-                                                                                 put-global-definition-hook
-                                                                                 get-global-definition-hook
-                                                                                 put-cte-hook
-                                                                                 gensym-hook
-                                                                                 error-hook
-                                                                                 define-top-level-value-hook
-                                                                                 local-eval-hook
-                                                                                 top-level-eval-hook
-                                                                                 annotation?
-                                                                                 set-syntax-object-wrap!
-                                                                                 set-syntax-object-expression!
-                                                                                 syntax-object-wrap
-                                                                                 syntax-object-expression
-                                                                                 syntax-object?
-                                                                                 make-syntax-object
-                                                                                 noexpand
-                                                                                 let-values
-                                                                                 define-structure
-                                                                                 unless
-                                                                                 when)
-                                                                                ((top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 ("m" top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 ("m" top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top)
-                                                                                 (top))
-                                                                                ("i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"))
-                                                                              #(top-ribcage
-                                                                                *top*
-                                                                                #t)))
-                                                                         (#%cons
-                                                                           g773
-                                                                           (#%cons
-                                                                             g785
-                                                                             (#%cons
-                                                                               g786
-                                                                               g787))))
-                                                                       ((top-level-value
-                                                                          'syntax-error)
-                                                                         g769
-                                                                         '"invalid exports list in"))])
-                                                                g779)
-                                                              (#%syntax-error
-                                                                g774))])
-                                                        (#%$syntax-dispatch
-                                                          g774
-                                                          '(any any
-                                                                each-any
-                                                                .
-                                                                each-any))))])
-                                                (#%$syntax-dispatch
-                                                  g774
-                                                  '(any each-any
-                                                        .
-                                                        each-any)))])
-                                            g769)])
-                                        g772)])
-                                    g769))])
-                              (case-lambda
-                                [(g788)
-                                 ((case-lambda
-                                    [(g789)
-                                     ((case-lambda
-                                        [(g790)
-                                         (if g790
-                                             (#%apply
-                                               (case-lambda
-                                                 [(g791 g792)
-                                                  (if ((top-level-value
-                                                         'identifier?)
-                                                        g791)
-                                                      ((top-level-value
-                                                         'andmap)
-                                                        g770
-                                                        g792)
-                                                      '#f)])
-                                               g790)
-                                             ((case-lambda
-                                                [(g793)
-                                                 ((top-level-value
-                                                    'identifier?)
-                                                   g793)])
-                                               g789))])
-                                       (#%$syntax-dispatch
-                                         g789
-                                         '(any . each-any)))])
-                                   g788)]))])
-                          (void))]))
-                ((case-lambda
-                   [()
-                    ((case-lambda
-                       [(g794 g795)
-                        ((case-lambda
-                           [(g796 g797)
-                            (begin
-                              (set! g794 g796)
-                              (set! g795 g797)
-                              (begin
-                                (g12 'import
-                                     (case-lambda
-                                       [(g798) (g795 g798 '#f)]))
-                                (g12 'import-only
-                                     (case-lambda
-                                       [(g799) (g795 g799 '#t)]))))])
-                          (case-lambda
-                            [(g800 g801)
-                             ((case-lambda
-                                [(g802)
-                                 ((case-lambda
-                                    [(g803)
-                                     (if ((top-level-value 'memv)
-                                           g803
-                                           '($module))
-                                         ((case-lambda
-                                            [(g804)
-                                             ((case-lambda
-                                                [(g805)
-                                                 ((case-lambda
-                                                    [()
-                                                     (g163
-                                                       (case-lambda
-                                                         [(g806)
-                                                          ((case-lambda
-                                                             [(g807)
-                                                              (g1 ((top-level-value
-                                                                     'syntax-object->datum)
-                                                                    g807)
-                                                                  ((case-lambda
-                                                                     [(g808)
-                                                                      (g45 g808
-                                                                           (if ((top-level-value
-                                                                                  'eq?)
-                                                                                 ((top-level-value
-                                                                                    'car)
-                                                                                   g808)
-                                                                                 '#f)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 'shift
-                                                                                 (g47 '((top))))
-                                                                               (g47 '((top)))))])
-                                                                    (g99 g805
-                                                                         (g46 (g4 g807)))))])
-                                                            (if ((top-level-value
-                                                                   'pair?)
-                                                                  g806)
-                                                                ((top-level-value
-                                                                   'car)
-                                                                  g806)
-                                                                g806))])
-                                                       (g130 g804))]))])
-                                               (g181 g800 g804))])
-                                           (g26 g802))
-                                         (if ((top-level-value 'memv)
-                                               g803
-                                               '(displaced-lexical))
-                                             (g34 g800)
-                                             ((top-level-value
-                                                'syntax-error)
-                                               g800
-                                               '"unknown module")))])
-                                   (g25 g802))])
-                               (g801 g800))])
-                          (case-lambda
-                            [(g809 g810)
-                             (case-lambda
-                               [(g811)
-                                ((case-lambda
-                                   [(g812 g813 g814 g815 g816 g817)
-                                    ((case-lambda
-                                       [(g818 g819 g820 g821 g822 g823)
-                                        (begin
-                                          (set! g812 g818)
-                                          (set! g813 g819)
-                                          (set! g814 g820)
-                                          (set! g815 g821)
-                                          (set! g816 g822)
-                                          (set! g817 g823)
-                                          ((case-lambda
-                                             [(g824)
-                                              ((case-lambda
-                                                 [(g825)
-                                                  (if g825
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g826 g827)
-                                                           ((case-lambda
-                                                              [(g828)
-                                                               ((case-lambda
-                                                                  [(g829)
-                                                                   (if g829
-                                                                       (#%apply
-                                                                         (case-lambda
-                                                                           [(g830)
-                                                                            (#%cons
-                                                                              '#(syntax-object
-                                                                                 begin
-                                                                                 ((top)
-                                                                                   #(ribcage
-                                                                                     #(d)
-                                                                                     #((top))
-                                                                                     #("i"))
-                                                                                   #(ribcage
-                                                                                     #(_
-                                                                                       m)
-                                                                                     #((top)
-                                                                                       (top))
-                                                                                     #("i"
-                                                                                       "i"))
-                                                                                   #(ribcage
-                                                                                     (modspec*
-                                                                                       modspec
-                                                                                       gen-mid
-                                                                                       prefix-drop
-                                                                                       prefix-add
-                                                                                       difference)
-                                                                                     ((top)
-                                                                                       (top)
-                                                                                       (top)
-                                                                                       (top)
-                                                                                       (top)
-                                                                                       (top))
-                                                                                     ("i" "i"
-                                                                                          "i"
-                                                                                          "i"
-                                                                                          "i"
-                                                                                          "i"))
-                                                                                   #(ribcage
-                                                                                     #(r)
-                                                                                     #((top))
-                                                                                     #("i"))
-                                                                                   #(ribcage
-                                                                                     ()
-                                                                                     ()
-                                                                                     ())
-                                                                                   #(ribcage
-                                                                                     #(orig
-                                                                                       import-only?)
-                                                                                     #((top)
-                                                                                       (top))
-                                                                                     #("i"
-                                                                                       "i"))
-                                                                                   #(ribcage
-                                                                                     ($import-help
-                                                                                       $module-exports)
-                                                                                     ((top)
-                                                                                       (top))
-                                                                                     ("i" "i"))
-                                                                                   #(ribcage
-                                                                                     (lambda-var-list
-                                                                                      gen-var
-                                                                                      strip
-                                                                                      strip*
-                                                                                      strip-annotation
-                                                                                      ellipsis?
-                                                                                      chi-void
-                                                                                      chi-local-syntax
-                                                                                      chi-lambda-clause
-                                                                                      parse-begin
-                                                                                      parse-alias
-                                                                                      parse-eval-when
-                                                                                      parse-meta
-                                                                                      parse-define-syntax
-                                                                                      parse-define
-                                                                                      parse-import
-                                                                                      parse-module
-                                                                                      do-import!
-                                                                                      lookup-import-label
-                                                                                      import-mark-delta
-                                                                                      chi-internal
-                                                                                      chi-body
-                                                                                      chi-macro
-                                                                                      chi-set!
-                                                                                      chi-application
-                                                                                      chi-expr
-                                                                                      chi
-                                                                                      chi-sequence
-                                                                                      chi-meta-frob
-                                                                                      chi-frobs
-                                                                                      ct-eval/residualize3
-                                                                                      ct-eval/residualize2
-                                                                                      rt-eval/residualize
-                                                                                      initial-mode-set
-                                                                                      update-mode-set
-                                                                                      do-top-import
-                                                                                      vfor-each
-                                                                                      vmap
-                                                                                      chi-external
-                                                                                      check-defined-ids
-                                                                                      check-module-exports
-                                                                                      id-set-diff
-                                                                                      chi-top-module
-                                                                                      set-frob-meta?!
-                                                                                      set-frob-e!
-                                                                                      frob-meta?
-                                                                                      frob-e
-                                                                                      frob?
-                                                                                      make-frob
-                                                                                      create-module-binding
-                                                                                      set-module-binding-exported!
-                                                                                      set-module-binding-val!
-                                                                                      set-module-binding-imps!
-                                                                                      set-module-binding-label!
-                                                                                      set-module-binding-id!
-                                                                                      set-module-binding-type!
-                                                                                      module-binding-exported
-                                                                                      module-binding-val
-                                                                                      module-binding-imps
-                                                                                      module-binding-label
-                                                                                      module-binding-id
-                                                                                      module-binding-type
-                                                                                      module-binding?
-                                                                                      make-module-binding
-                                                                                      make-resolved-interface
-                                                                                      make-unresolved-interface
-                                                                                      set-interface-token!
-                                                                                      set-interface-exports!
-                                                                                      set-interface-marks!
-                                                                                      interface-token
-                                                                                      interface-exports
-                                                                                      interface-marks
-                                                                                      interface?
-                                                                                      make-interface
-                                                                                      flatten-exports
-                                                                                      chi-top
-                                                                                      chi-top-sequence
-                                                                                      chi-top*
-                                                                                      syntax-type
-                                                                                      chi-when-list
-                                                                                      source-wrap
-                                                                                      wrap
-                                                                                      bound-id-member?
-                                                                                      invalid-ids-error
-                                                                                      distinct-bound-ids?
-                                                                                      valid-bound-ids?
-                                                                                      bound-id=?
-                                                                                      help-bound-id=?
-                                                                                      literal-id=?
-                                                                                      free-id=?
-                                                                                      id-var-name
-                                                                                      id-var-name-loc
-                                                                                      id-var-name&marks
-                                                                                      id-var-name-loc&marks
-                                                                                      top-id-free-var-name
-                                                                                      top-id-bound-var-name
-                                                                                      anon
-                                                                                      diff-marks
-                                                                                      same-marks?
-                                                                                      join-subst
-                                                                                      join-marks
-                                                                                      join-wraps
-                                                                                      smart-append
-                                                                                      resolved-id-var-name
-                                                                                      id->resolved-id
-                                                                                      make-resolved-id
-                                                                                      make-binding-wrap
-                                                                                      store-import-binding
-                                                                                      lookup-import-binding-name
-                                                                                      extend-ribcage-subst!
-                                                                                      extend-ribcage-barrier-help!
-                                                                                      extend-ribcage-barrier!
-                                                                                      import-extend-ribcage!
-                                                                                      extend-ribcage!
-                                                                                      make-empty-ribcage
-                                                                                      barrier-marker
-                                                                                      new-mark
-                                                                                      anti-mark
-                                                                                      the-anti-mark
-                                                                                      set-env-wrap!
-                                                                                      set-env-top-ribcage!
-                                                                                      env-wrap
-                                                                                      env-top-ribcage
-                                                                                      env?
-                                                                                      make-env
-                                                                                      set-import-interface-new-marks!
-                                                                                      set-import-interface-interface!
-                                                                                      import-interface-new-marks
-                                                                                      import-interface-interface
-                                                                                      import-interface?
-                                                                                      make-import-interface
-                                                                                      set-top-ribcage-mutable?!
-                                                                                      set-top-ribcage-key!
-                                                                                      top-ribcage-mutable?
-                                                                                      top-ribcage-key
-                                                                                      top-ribcage?
-                                                                                      make-top-ribcage
-                                                                                      set-ribcage-labels!
-                                                                                      set-ribcage-marks!
-                                                                                      set-ribcage-symnames!
-                                                                                      ribcage-labels
-                                                                                      ribcage-marks
-                                                                                      ribcage-symnames
-                                                                                      ribcage?
-                                                                                      make-ribcage
-                                                                                      gen-labels
-                                                                                      label?
-                                                                                      gen-label
-                                                                                      set-indirect-label!
-                                                                                      get-indirect-label
-                                                                                      indirect-label?
-                                                                                      gen-indirect-label
-                                                                                      anon
-                                                                                      only-top-marked?
-                                                                                      top-marked?
-                                                                                      top-wrap
-                                                                                      empty-wrap
-                                                                                      wrap-subst
-                                                                                      wrap-marks
-                                                                                      make-wrap
-                                                                                      id-sym-name&marks
-                                                                                      id-subst
-                                                                                      id-marks
-                                                                                      id-sym-name
-                                                                                      id?
-                                                                                      nonsymbol-id?
-                                                                                      global-extend
-                                                                                      defer-or-eval-transformer
-                                                                                      make-transformer-binding
-                                                                                      lookup
-                                                                                      lookup*
-                                                                                      displaced-lexical-error
-                                                                                      displaced-lexical?
-                                                                                      extend-var-env*
-                                                                                      extend-env*
-                                                                                      extend-env
-                                                                                      null-env
-                                                                                      binding?
-                                                                                      set-binding-value!
-                                                                                      set-binding-type!
-                                                                                      binding-value
-                                                                                      binding-type
-                                                                                      make-binding
-                                                                                      sanitize-binding
-                                                                                      arg-check
-                                                                                      no-source
-                                                                                      unannotate
-                                                                                      self-evaluating?
-                                                                                      lexical-var?
-                                                                                      build-lexical-var
-                                                                                      build-top-module
-                                                                                      build-body
-                                                                                      build-letrec
-                                                                                      build-sequence
-                                                                                      build-data
-                                                                                      build-primref
-                                                                                      built-lambda?
-                                                                                      build-lambda
-                                                                                      build-revisit-only
-                                                                                      build-visit-only
-                                                                                      build-cte-install
-                                                                                      build-global-definition
-                                                                                      build-global-assignment
-                                                                                      build-global-reference
-                                                                                      build-lexical-assignment
-                                                                                      build-lexical-reference
-                                                                                      build-conditional
-                                                                                      build-application
-                                                                                      generate-id
-                                                                                      put-import-binding
-                                                                                      get-import-binding
-                                                                                      read-only-binding?
-                                                                                      put-global-definition-hook
-                                                                                      get-global-definition-hook
-                                                                                      put-cte-hook
-                                                                                      gensym-hook
-                                                                                      error-hook
-                                                                                      define-top-level-value-hook
-                                                                                      local-eval-hook
-                                                                                      top-level-eval-hook
-                                                                                      annotation?
-                                                                                      set-syntax-object-wrap!
-                                                                                      set-syntax-object-expression!
-                                                                                      syntax-object-wrap
-                                                                                      syntax-object-expression
-                                                                                      syntax-object?
-                                                                                      make-syntax-object
-                                                                                      noexpand
-                                                                                      let-values
-                                                                                      define-structure
-                                                                                      unless
-                                                                                      when)
-                                                                                     ((top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      ("m" top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      ("m" top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top))
-                                                                                     ("i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"))
-                                                                                   #(top-ribcage
-                                                                                     *top*
-                                                                                     #t)))
-                                                                              g830)])
-                                                                         g829)
-                                                                       (#%syntax-error
-                                                                         g828))])
-                                                                 (#%$syntax-dispatch
-                                                                   g828
-                                                                   'each-any))])
-                                                             ((top-level-value
-                                                                'map)
-                                                               g817
-                                                               g827))])
-                                                        g825)
-                                                      (#%syntax-error
-                                                        g824))])
-                                                (#%$syntax-dispatch
-                                                  g824
-                                                  '(any . each-any)))])
-                                            g809))])
-                                      (case-lambda
-                                        [(g831 g832)
-                                         (if ((top-level-value 'null?)
-                                               g831)
-                                             g831
-                                             (if (g118
-                                                   ((top-level-value 'car)
-                                                     g831)
-                                                   g832)
-                                                 (g812
-                                                   ((top-level-value 'cdr)
-                                                     g831)
-                                                   g832)
-                                                 ((top-level-value 'cons)
-                                                   ((top-level-value 'car)
-                                                     g831)
-                                                   (g812
-                                                     ((top-level-value
-                                                        'cdr)
-                                                       g831)
-                                                     g832))))])
-                                      (case-lambda
-                                        [(g833)
-                                         ((case-lambda
-                                            [(g834)
-                                             (case-lambda
-                                               [(g835)
-                                                ((top-level-value
-                                                   'datum->syntax-object)
-                                                  g835
-                                                  ((top-level-value
-                                                     'string->symbol)
-                                                    ((top-level-value
-                                                       'string-append)
-                                                      g834
-                                                      ((top-level-value
-                                                         'symbol->string)
-                                                        ((top-level-value
-                                                           'syntax-object->datum)
-                                                          g835)))))])])
-                                           ((top-level-value
-                                              'symbol->string)
-                                             ((top-level-value
-                                                'syntax-object->datum)
-                                               g833)))])
-                                      (case-lambda
-                                        [(g836)
-                                         ((case-lambda
-                                            [(g837)
-                                             (case-lambda
-                                               [(g838)
-                                                ((case-lambda
-                                                   [(g839)
-                                                    ((case-lambda
-                                                       [(g840 g841)
-                                                        (begin
-                                                          (if ((top-level-value
-                                                                 'not)
-                                                                (if ((top-level-value
-                                                                       'fx>=)
-                                                                      g841
-                                                                      g840)
-                                                                    ((top-level-value
-                                                                       'string=?)
-                                                                      ((top-level-value
-                                                                         'substring)
-                                                                        g839
-                                                                        '0
-                                                                        g840)
-                                                                      g837)
-                                                                    '#f))
-                                                              ((top-level-value
-                                                                 'syntax-error)
-                                                                g838
-                                                                ((top-level-value
-                                                                   'string-append)
-                                                                  '"missing expected prefix "
-                                                                  g837))
-                                                              (#%void))
-                                                          ((top-level-value
-                                                             'datum->syntax-object)
-                                                            g838
-                                                            ((top-level-value
-                                                               'string->symbol)
-                                                              ((top-level-value
-                                                                 'substring)
-                                                                g839
-                                                                g840
-                                                                g841))))])
-                                                      ((top-level-value
-                                                         'string-length)
-                                                        g837)
-                                                      ((top-level-value
-                                                         'string-length)
-                                                        g839))])
-                                                  ((top-level-value
-                                                     'symbol->string)
-                                                    ((top-level-value
-                                                       'syntax-object->datum)
-                                                      g838)))])])
-                                           ((top-level-value
-                                              'symbol->string)
-                                             ((top-level-value
-                                                'syntax-object->datum)
-                                               g836)))])
-                                      (case-lambda
-                                        [(g842)
-                                         ((top-level-value
-                                            'datum->syntax-object)
-                                           g842
-                                           ((top-level-value 'gensym)))])
-                                      (case-lambda
-                                        [(g843 g844)
-                                         ((case-lambda
-                                            [(g845)
-                                             ((case-lambda
-                                                [(g846)
-                                                 (if g846
-                                                     (#%apply
-                                                       (case-lambda
-                                                         [(g847 g848)
-                                                          ((case-lambda
-                                                             [(g849)
-                                                              ((case-lambda
-                                                                 [(g850)
-                                                                  (if (if g850
-                                                                          (#%apply
-                                                                            (case-lambda
-                                                                              [(g851
-                                                                                g852)
-                                                                               ((top-level-value
-                                                                                  'andmap)
-                                                                                 (top-level-value
-                                                                                   'identifier?)
-                                                                                 g852)])
-                                                                            g850)
-                                                                          '#f)
-                                                                      (#%apply
-                                                                        (case-lambda
-                                                                          [(g853
-                                                                            g854)
-                                                                           ((top-level-value
-                                                                              'call-with-values)
-                                                                             (case-lambda
-                                                                               [()
-                                                                                (g816
-                                                                                  g853
-                                                                                  '#f)])
-                                                                             (case-lambda
-                                                                               [(g855
-                                                                                 g856
-                                                                                 g857)
-                                                                                ((case-lambda
-                                                                                   [(g858)
-                                                                                    ((case-lambda
-                                                                                       [(g859)
-                                                                                        (if g859
-                                                                                            (#%apply
-                                                                                              (case-lambda
-                                                                                                [(g860
-                                                                                                  g861)
-                                                                                                 ((top-level-value
-                                                                                                    'values)
-                                                                                                   g855
-                                                                                                   (#%list
-                                                                                                     '#(syntax-object
-                                                                                                        begin
-                                                                                                        ((top)
-                                                                                                          #(ribcage
-                                                                                                            #(d
-                                                                                                              tmid)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            ()
-                                                                                                            ()
-                                                                                                            ())
-                                                                                                          #(ribcage
-                                                                                                            #(mid
-                                                                                                              d
-                                                                                                              exports)
-                                                                                                            #((top)
-                                                                                                              (top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            #(m
-                                                                                                              id)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            #(orig
-                                                                                                              import-only?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            ()
-                                                                                                            ()
-                                                                                                            ())
-                                                                                                          #(ribcage
-                                                                                                            #(m
-                                                                                                              exports?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            (modspec*
-                                                                                                              modspec
-                                                                                                              gen-mid
-                                                                                                              prefix-drop
-                                                                                                              prefix-add
-                                                                                                              difference)
-                                                                                                            ((top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top))
-                                                                                                            ("i" "i"
-                                                                                                                 "i"
-                                                                                                                 "i"
-                                                                                                                 "i"
-                                                                                                                 "i"))
-                                                                                                          #(ribcage
-                                                                                                            #(r)
-                                                                                                            #((top))
-                                                                                                            #("i"))
-                                                                                                          #(ribcage
-                                                                                                            ()
-                                                                                                            ()
-                                                                                                            ())
-                                                                                                          #(ribcage
-                                                                                                            #(orig
-                                                                                                              import-only?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            ($import-help
-                                                                                                              $module-exports)
-                                                                                                            ((top)
-                                                                                                              (top))
-                                                                                                            ("i" "i"))
-                                                                                                          #(ribcage
-                                                                                                            (lambda-var-list
-                                                                                                             gen-var
-                                                                                                             strip
-                                                                                                             strip*
-                                                                                                             strip-annotation
-                                                                                                             ellipsis?
-                                                                                                             chi-void
-                                                                                                             chi-local-syntax
-                                                                                                             chi-lambda-clause
-                                                                                                             parse-begin
-                                                                                                             parse-alias
-                                                                                                             parse-eval-when
-                                                                                                             parse-meta
-                                                                                                             parse-define-syntax
-                                                                                                             parse-define
-                                                                                                             parse-import
-                                                                                                             parse-module
-                                                                                                             do-import!
-                                                                                                             lookup-import-label
-                                                                                                             import-mark-delta
-                                                                                                             chi-internal
-                                                                                                             chi-body
-                                                                                                             chi-macro
-                                                                                                             chi-set!
-                                                                                                             chi-application
-                                                                                                             chi-expr
-                                                                                                             chi
-                                                                                                             chi-sequence
-                                                                                                             chi-meta-frob
-                                                                                                             chi-frobs
-                                                                                                             ct-eval/residualize3
-                                                                                                             ct-eval/residualize2
-                                                                                                             rt-eval/residualize
-                                                                                                             initial-mode-set
-                                                                                                             update-mode-set
-                                                                                                             do-top-import
-                                                                                                             vfor-each
-                                                                                                             vmap
-                                                                                                             chi-external
-                                                                                                             check-defined-ids
-                                                                                                             check-module-exports
-                                                                                                             id-set-diff
-                                                                                                             chi-top-module
-                                                                                                             set-frob-meta?!
-                                                                                                             set-frob-e!
-                                                                                                             frob-meta?
-                                                                                                             frob-e
-                                                                                                             frob?
-                                                                                                             make-frob
-                                                                                                             create-module-binding
-                                                                                                             set-module-binding-exported!
-                                                                                                             set-module-binding-val!
-                                                                                                             set-module-binding-imps!
-                                                                                                             set-module-binding-label!
-                                                                                                             set-module-binding-id!
-                                                                                                             set-module-binding-type!
-                                                                                                             module-binding-exported
-                                                                                                             module-binding-val
-                                                                                                             module-binding-imps
-                                                                                                             module-binding-label
-                                                                                                             module-binding-id
-                                                                                                             module-binding-type
-                                                                                                             module-binding?
-                                                                                                             make-module-binding
-                                                                                                             make-resolved-interface
-                                                                                                             make-unresolved-interface
-                                                                                                             set-interface-token!
-                                                                                                             set-interface-exports!
-                                                                                                             set-interface-marks!
-                                                                                                             interface-token
-                                                                                                             interface-exports
-                                                                                                             interface-marks
-                                                                                                             interface?
-                                                                                                             make-interface
-                                                                                                             flatten-exports
-                                                                                                             chi-top
-                                                                                                             chi-top-sequence
-                                                                                                             chi-top*
-                                                                                                             syntax-type
-                                                                                                             chi-when-list
-                                                                                                             source-wrap
-                                                                                                             wrap
-                                                                                                             bound-id-member?
-                                                                                                             invalid-ids-error
-                                                                                                             distinct-bound-ids?
-                                                                                                             valid-bound-ids?
-                                                                                                             bound-id=?
-                                                                                                             help-bound-id=?
-                                                                                                             literal-id=?
-                                                                                                             free-id=?
-                                                                                                             id-var-name
-                                                                                                             id-var-name-loc
-                                                                                                             id-var-name&marks
-                                                                                                             id-var-name-loc&marks
-                                                                                                             top-id-free-var-name
-                                                                                                             top-id-bound-var-name
-                                                                                                             anon
-                                                                                                             diff-marks
-                                                                                                             same-marks?
-                                                                                                             join-subst
-                                                                                                             join-marks
-                                                                                                             join-wraps
-                                                                                                             smart-append
-                                                                                                             resolved-id-var-name
-                                                                                                             id->resolved-id
-                                                                                                             make-resolved-id
-                                                                                                             make-binding-wrap
-                                                                                                             store-import-binding
-                                                                                                             lookup-import-binding-name
-                                                                                                             extend-ribcage-subst!
-                                                                                                             extend-ribcage-barrier-help!
-                                                                                                             extend-ribcage-barrier!
-                                                                                                             import-extend-ribcage!
-                                                                                                             extend-ribcage!
-                                                                                                             make-empty-ribcage
-                                                                                                             barrier-marker
-                                                                                                             new-mark
-                                                                                                             anti-mark
-                                                                                                             the-anti-mark
-                                                                                                             set-env-wrap!
-                                                                                                             set-env-top-ribcage!
-                                                                                                             env-wrap
-                                                                                                             env-top-ribcage
-                                                                                                             env?
-                                                                                                             make-env
-                                                                                                             set-import-interface-new-marks!
-                                                                                                             set-import-interface-interface!
-                                                                                                             import-interface-new-marks
-                                                                                                             import-interface-interface
-                                                                                                             import-interface?
-                                                                                                             make-import-interface
-                                                                                                             set-top-ribcage-mutable?!
-                                                                                                             set-top-ribcage-key!
-                                                                                                             top-ribcage-mutable?
-                                                                                                             top-ribcage-key
-                                                                                                             top-ribcage?
-                                                                                                             make-top-ribcage
-                                                                                                             set-ribcage-labels!
-                                                                                                             set-ribcage-marks!
-                                                                                                             set-ribcage-symnames!
-                                                                                                             ribcage-labels
-                                                                                                             ribcage-marks
-                                                                                                             ribcage-symnames
-                                                                                                             ribcage?
-                                                                                                             make-ribcage
-                                                                                                             gen-labels
-                                                                                                             label?
-                                                                                                             gen-label
-                                                                                                             set-indirect-label!
-                                                                                                             get-indirect-label
-                                                                                                             indirect-label?
-                                                                                                             gen-indirect-label
-                                                                                                             anon
-                                                                                                             only-top-marked?
-                                                                                                             top-marked?
-                                                                                                             top-wrap
-                                                                                                             empty-wrap
-                                                                                                             wrap-subst
-                                                                                                             wrap-marks
-                                                                                                             make-wrap
-                                                                                                             id-sym-name&marks
-                                                                                                             id-subst
-                                                                                                             id-marks
-                                                                                                             id-sym-name
-                                                                                                             id?
-                                                                                                             nonsymbol-id?
-                                                                                                             global-extend
-                                                                                                             defer-or-eval-transformer
-                                                                                                             make-transformer-binding
-                                                                                                             lookup
-                                                                                                             lookup*
-                                                                                                             displaced-lexical-error
-                                                                                                             displaced-lexical?
-                                                                                                             extend-var-env*
-                                                                                                             extend-env*
-                                                                                                             extend-env
-                                                                                                             null-env
-                                                                                                             binding?
-                                                                                                             set-binding-value!
-                                                                                                             set-binding-type!
-                                                                                                             binding-value
-                                                                                                             binding-type
-                                                                                                             make-binding
-                                                                                                             sanitize-binding
-                                                                                                             arg-check
-                                                                                                             no-source
-                                                                                                             unannotate
-                                                                                                             self-evaluating?
-                                                                                                             lexical-var?
-                                                                                                             build-lexical-var
-                                                                                                             build-top-module
-                                                                                                             build-body
-                                                                                                             build-letrec
-                                                                                                             build-sequence
-                                                                                                             build-data
-                                                                                                             build-primref
-                                                                                                             built-lambda?
-                                                                                                             build-lambda
-                                                                                                             build-revisit-only
-                                                                                                             build-visit-only
-                                                                                                             build-cte-install
-                                                                                                             build-global-definition
-                                                                                                             build-global-assignment
-                                                                                                             build-global-reference
-                                                                                                             build-lexical-assignment
-                                                                                                             build-lexical-reference
-                                                                                                             build-conditional
-                                                                                                             build-application
-                                                                                                             generate-id
-                                                                                                             put-import-binding
-                                                                                                             get-import-binding
-                                                                                                             read-only-binding?
-                                                                                                             put-global-definition-hook
-                                                                                                             get-global-definition-hook
-                                                                                                             put-cte-hook
-                                                                                                             gensym-hook
-                                                                                                             error-hook
-                                                                                                             define-top-level-value-hook
-                                                                                                             local-eval-hook
-                                                                                                             top-level-eval-hook
-                                                                                                             annotation?
-                                                                                                             set-syntax-object-wrap!
-                                                                                                             set-syntax-object-expression!
-                                                                                                             syntax-object-wrap
-                                                                                                             syntax-object-expression
-                                                                                                             syntax-object?
-                                                                                                             make-syntax-object
-                                                                                                             noexpand
-                                                                                                             let-values
-                                                                                                             define-structure
-                                                                                                             unless
-                                                                                                             when)
-                                                                                                            ((top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             ("m" top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             ("m" top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top))
-                                                                                                            ("i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"))
-                                                                                                          #(top-ribcage
-                                                                                                            *top*
-                                                                                                            #t)))
-                                                                                                     (#%list
-                                                                                                       '#(syntax-object
-                                                                                                          $module
-                                                                                                          ((top)
-                                                                                                            #(ribcage
-                                                                                                              #(d
-                                                                                                                tmid)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(mid
-                                                                                                                d
-                                                                                                                exports)
-                                                                                                              #((top)
-                                                                                                                (top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(m
-                                                                                                                id)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(orig
-                                                                                                                import-only?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(m
-                                                                                                                exports?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              (modspec*
-                                                                                                                modspec
-                                                                                                                gen-mid
-                                                                                                                prefix-drop
-                                                                                                                prefix-add
-                                                                                                                difference)
-                                                                                                              ((top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top))
-                                                                                                              ("i" "i"
-                                                                                                                   "i"
-                                                                                                                   "i"
-                                                                                                                   "i"
-                                                                                                                   "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(r)
-                                                                                                              #((top))
-                                                                                                              #("i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(orig
-                                                                                                                import-only?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ($import-help
-                                                                                                                $module-exports)
-                                                                                                              ((top)
-                                                                                                                (top))
-                                                                                                              ("i" "i"))
-                                                                                                            #(ribcage
-                                                                                                              (lambda-var-list
-                                                                                                               gen-var
-                                                                                                               strip
-                                                                                                               strip*
-                                                                                                               strip-annotation
-                                                                                                               ellipsis?
-                                                                                                               chi-void
-                                                                                                               chi-local-syntax
-                                                                                                               chi-lambda-clause
-                                                                                                               parse-begin
-                                                                                                               parse-alias
-                                                                                                               parse-eval-when
-                                                                                                               parse-meta
-                                                                                                               parse-define-syntax
-                                                                                                               parse-define
-                                                                                                               parse-import
-                                                                                                               parse-module
-                                                                                                               do-import!
-                                                                                                               lookup-import-label
-                                                                                                               import-mark-delta
-                                                                                                               chi-internal
-                                                                                                               chi-body
-                                                                                                               chi-macro
-                                                                                                               chi-set!
-                                                                                                               chi-application
-                                                                                                               chi-expr
-                                                                                                               chi
-                                                                                                               chi-sequence
-                                                                                                               chi-meta-frob
-                                                                                                               chi-frobs
-                                                                                                               ct-eval/residualize3
-                                                                                                               ct-eval/residualize2
-                                                                                                               rt-eval/residualize
-                                                                                                               initial-mode-set
-                                                                                                               update-mode-set
-                                                                                                               do-top-import
-                                                                                                               vfor-each
-                                                                                                               vmap
-                                                                                                               chi-external
-                                                                                                               check-defined-ids
-                                                                                                               check-module-exports
-                                                                                                               id-set-diff
-                                                                                                               chi-top-module
-                                                                                                               set-frob-meta?!
-                                                                                                               set-frob-e!
-                                                                                                               frob-meta?
-                                                                                                               frob-e
-                                                                                                               frob?
-                                                                                                               make-frob
-                                                                                                               create-module-binding
-                                                                                                               set-module-binding-exported!
-                                                                                                               set-module-binding-val!
-                                                                                                               set-module-binding-imps!
-                                                                                                               set-module-binding-label!
-                                                                                                               set-module-binding-id!
-                                                                                                               set-module-binding-type!
-                                                                                                               module-binding-exported
-                                                                                                               module-binding-val
-                                                                                                               module-binding-imps
-                                                                                                               module-binding-label
-                                                                                                               module-binding-id
-                                                                                                               module-binding-type
-                                                                                                               module-binding?
-                                                                                                               make-module-binding
-                                                                                                               make-resolved-interface
-                                                                                                               make-unresolved-interface
-                                                                                                               set-interface-token!
-                                                                                                               set-interface-exports!
-                                                                                                               set-interface-marks!
-                                                                                                               interface-token
-                                                                                                               interface-exports
-                                                                                                               interface-marks
-                                                                                                               interface?
-                                                                                                               make-interface
-                                                                                                               flatten-exports
-                                                                                                               chi-top
-                                                                                                               chi-top-sequence
-                                                                                                               chi-top*
-                                                                                                               syntax-type
-                                                                                                               chi-when-list
-                                                                                                               source-wrap
-                                                                                                               wrap
-                                                                                                               bound-id-member?
-                                                                                                               invalid-ids-error
-                                                                                                               distinct-bound-ids?
-                                                                                                               valid-bound-ids?
-                                                                                                               bound-id=?
-                                                                                                               help-bound-id=?
-                                                                                                               literal-id=?
-                                                                                                               free-id=?
-                                                                                                               id-var-name
-                                                                                                               id-var-name-loc
-                                                                                                               id-var-name&marks
-                                                                                                               id-var-name-loc&marks
-                                                                                                               top-id-free-var-name
-                                                                                                               top-id-bound-var-name
-                                                                                                               anon
-                                                                                                               diff-marks
-                                                                                                               same-marks?
-                                                                                                               join-subst
-                                                                                                               join-marks
-                                                                                                               join-wraps
-                                                                                                               smart-append
-                                                                                                               resolved-id-var-name
-                                                                                                               id->resolved-id
-                                                                                                               make-resolved-id
-                                                                                                               make-binding-wrap
-                                                                                                               store-import-binding
-                                                                                                               lookup-import-binding-name
-                                                                                                               extend-ribcage-subst!
-                                                                                                               extend-ribcage-barrier-help!
-                                                                                                               extend-ribcage-barrier!
-                                                                                                               import-extend-ribcage!
-                                                                                                               extend-ribcage!
-                                                                                                               make-empty-ribcage
-                                                                                                               barrier-marker
-                                                                                                               new-mark
-                                                                                                               anti-mark
-                                                                                                               the-anti-mark
-                                                                                                               set-env-wrap!
-                                                                                                               set-env-top-ribcage!
-                                                                                                               env-wrap
-                                                                                                               env-top-ribcage
-                                                                                                               env?
-                                                                                                               make-env
-                                                                                                               set-import-interface-new-marks!
-                                                                                                               set-import-interface-interface!
-                                                                                                               import-interface-new-marks
-                                                                                                               import-interface-interface
-                                                                                                               import-interface?
-                                                                                                               make-import-interface
-                                                                                                               set-top-ribcage-mutable?!
-                                                                                                               set-top-ribcage-key!
-                                                                                                               top-ribcage-mutable?
-                                                                                                               top-ribcage-key
-                                                                                                               top-ribcage?
-                                                                                                               make-top-ribcage
-                                                                                                               set-ribcage-labels!
-                                                                                                               set-ribcage-marks!
-                                                                                                               set-ribcage-symnames!
-                                                                                                               ribcage-labels
-                                                                                                               ribcage-marks
-                                                                                                               ribcage-symnames
-                                                                                                               ribcage?
-                                                                                                               make-ribcage
-                                                                                                               gen-labels
-                                                                                                               label?
-                                                                                                               gen-label
-                                                                                                               set-indirect-label!
-                                                                                                               get-indirect-label
-                                                                                                               indirect-label?
-                                                                                                               gen-indirect-label
-                                                                                                               anon
-                                                                                                               only-top-marked?
-                                                                                                               top-marked?
-                                                                                                               top-wrap
-                                                                                                               empty-wrap
-                                                                                                               wrap-subst
-                                                                                                               wrap-marks
-                                                                                                               make-wrap
-                                                                                                               id-sym-name&marks
-                                                                                                               id-subst
-                                                                                                               id-marks
-                                                                                                               id-sym-name
-                                                                                                               id?
-                                                                                                               nonsymbol-id?
-                                                                                                               global-extend
-                                                                                                               defer-or-eval-transformer
-                                                                                                               make-transformer-binding
-                                                                                                               lookup
-                                                                                                               lookup*
-                                                                                                               displaced-lexical-error
-                                                                                                               displaced-lexical?
-                                                                                                               extend-var-env*
-                                                                                                               extend-env*
-                                                                                                               extend-env
-                                                                                                               null-env
-                                                                                                               binding?
-                                                                                                               set-binding-value!
-                                                                                                               set-binding-type!
-                                                                                                               binding-value
-                                                                                                               binding-type
-                                                                                                               make-binding
-                                                                                                               sanitize-binding
-                                                                                                               arg-check
-                                                                                                               no-source
-                                                                                                               unannotate
-                                                                                                               self-evaluating?
-                                                                                                               lexical-var?
-                                                                                                               build-lexical-var
-                                                                                                               build-top-module
-                                                                                                               build-body
-                                                                                                               build-letrec
-                                                                                                               build-sequence
-                                                                                                               build-data
-                                                                                                               build-primref
-                                                                                                               built-lambda?
-                                                                                                               build-lambda
-                                                                                                               build-revisit-only
-                                                                                                               build-visit-only
-                                                                                                               build-cte-install
-                                                                                                               build-global-definition
-                                                                                                               build-global-assignment
-                                                                                                               build-global-reference
-                                                                                                               build-lexical-assignment
-                                                                                                               build-lexical-reference
-                                                                                                               build-conditional
-                                                                                                               build-application
-                                                                                                               generate-id
-                                                                                                               put-import-binding
-                                                                                                               get-import-binding
-                                                                                                               read-only-binding?
-                                                                                                               put-global-definition-hook
-                                                                                                               get-global-definition-hook
-                                                                                                               put-cte-hook
-                                                                                                               gensym-hook
-                                                                                                               error-hook
-                                                                                                               define-top-level-value-hook
-                                                                                                               local-eval-hook
-                                                                                                               top-level-eval-hook
-                                                                                                               annotation?
-                                                                                                               set-syntax-object-wrap!
-                                                                                                               set-syntax-object-expression!
-                                                                                                               syntax-object-wrap
-                                                                                                               syntax-object-expression
-                                                                                                               syntax-object?
-                                                                                                               make-syntax-object
-                                                                                                               noexpand
-                                                                                                               let-values
-                                                                                                               define-structure
-                                                                                                               unless
-                                                                                                               when)
-                                                                                                              ((top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               ("m" top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               ("m" top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top))
-                                                                                                              ("i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"))
-                                                                                                            #(top-ribcage
-                                                                                                              *top*
-                                                                                                              #t)))
-                                                                                                       g847
-                                                                                                       g861
-                                                                                                       g854
-                                                                                                       g860)
-                                                                                                     (#%list
-                                                                                                       '#(syntax-object
-                                                                                                          $import
-                                                                                                          ((top)
-                                                                                                            #(ribcage
-                                                                                                              #(d
-                                                                                                                tmid)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(mid
-                                                                                                                d
-                                                                                                                exports)
-                                                                                                              #((top)
-                                                                                                                (top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(m
-                                                                                                                id)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(orig
-                                                                                                                import-only?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(m
-                                                                                                                exports?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              (modspec*
-                                                                                                                modspec
-                                                                                                                gen-mid
-                                                                                                                prefix-drop
-                                                                                                                prefix-add
-                                                                                                                difference)
-                                                                                                              ((top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top)
-                                                                                                                (top))
-                                                                                                              ("i" "i"
-                                                                                                                   "i"
-                                                                                                                   "i"
-                                                                                                                   "i"
-                                                                                                                   "i"))
-                                                                                                            #(ribcage
-                                                                                                              #(r)
-                                                                                                              #((top))
-                                                                                                              #("i"))
-                                                                                                            #(ribcage
-                                                                                                              ()
-                                                                                                              ()
-                                                                                                              ())
-                                                                                                            #(ribcage
-                                                                                                              #(orig
-                                                                                                                import-only?)
-                                                                                                              #((top)
-                                                                                                                (top))
-                                                                                                              #("i"
-                                                                                                                "i"))
-                                                                                                            #(ribcage
-                                                                                                              ($import-help
-                                                                                                                $module-exports)
-                                                                                                              ((top)
-                                                                                                                (top))
-                                                                                                              ("i" "i"))
-                                                                                                            #(ribcage
-                                                                                                              (lambda-var-list
-                                                                                                               gen-var
-                                                                                                               strip
-                                                                                                               strip*
-                                                                                                               strip-annotation
-                                                                                                               ellipsis?
-                                                                                                               chi-void
-                                                                                                               chi-local-syntax
-                                                                                                               chi-lambda-clause
-                                                                                                               parse-begin
-                                                                                                               parse-alias
-                                                                                                               parse-eval-when
-                                                                                                               parse-meta
-                                                                                                               parse-define-syntax
-                                                                                                               parse-define
-                                                                                                               parse-import
-                                                                                                               parse-module
-                                                                                                               do-import!
-                                                                                                               lookup-import-label
-                                                                                                               import-mark-delta
-                                                                                                               chi-internal
-                                                                                                               chi-body
-                                                                                                               chi-macro
-                                                                                                               chi-set!
-                                                                                                               chi-application
-                                                                                                               chi-expr
-                                                                                                               chi
-                                                                                                               chi-sequence
-                                                                                                               chi-meta-frob
-                                                                                                               chi-frobs
-                                                                                                               ct-eval/residualize3
-                                                                                                               ct-eval/residualize2
-                                                                                                               rt-eval/residualize
-                                                                                                               initial-mode-set
-                                                                                                               update-mode-set
-                                                                                                               do-top-import
-                                                                                                               vfor-each
-                                                                                                               vmap
-                                                                                                               chi-external
-                                                                                                               check-defined-ids
-                                                                                                               check-module-exports
-                                                                                                               id-set-diff
-                                                                                                               chi-top-module
-                                                                                                               set-frob-meta?!
-                                                                                                               set-frob-e!
-                                                                                                               frob-meta?
-                                                                                                               frob-e
-                                                                                                               frob?
-                                                                                                               make-frob
-                                                                                                               create-module-binding
-                                                                                                               set-module-binding-exported!
-                                                                                                               set-module-binding-val!
-                                                                                                               set-module-binding-imps!
-                                                                                                               set-module-binding-label!
-                                                                                                               set-module-binding-id!
-                                                                                                               set-module-binding-type!
-                                                                                                               module-binding-exported
-                                                                                                               module-binding-val
-                                                                                                               module-binding-imps
-                                                                                                               module-binding-label
-                                                                                                               module-binding-id
-                                                                                                               module-binding-type
-                                                                                                               module-binding?
-                                                                                                               make-module-binding
-                                                                                                               make-resolved-interface
-                                                                                                               make-unresolved-interface
-                                                                                                               set-interface-token!
-                                                                                                               set-interface-exports!
-                                                                                                               set-interface-marks!
-                                                                                                               interface-token
-                                                                                                               interface-exports
-                                                                                                               interface-marks
-                                                                                                               interface?
-                                                                                                               make-interface
-                                                                                                               flatten-exports
-                                                                                                               chi-top
-                                                                                                               chi-top-sequence
-                                                                                                               chi-top*
-                                                                                                               syntax-type
-                                                                                                               chi-when-list
-                                                                                                               source-wrap
-                                                                                                               wrap
-                                                                                                               bound-id-member?
-                                                                                                               invalid-ids-error
-                                                                                                               distinct-bound-ids?
-                                                                                                               valid-bound-ids?
-                                                                                                               bound-id=?
-                                                                                                               help-bound-id=?
-                                                                                                               literal-id=?
-                                                                                                               free-id=?
-                                                                                                               id-var-name
-                                                                                                               id-var-name-loc
-                                                                                                               id-var-name&marks
-                                                                                                               id-var-name-loc&marks
-                                                                                                               top-id-free-var-name
-                                                                                                               top-id-bound-var-name
-                                                                                                               anon
-                                                                                                               diff-marks
-                                                                                                               same-marks?
-                                                                                                               join-subst
-                                                                                                               join-marks
-                                                                                                               join-wraps
-                                                                                                               smart-append
-                                                                                                               resolved-id-var-name
-                                                                                                               id->resolved-id
-                                                                                                               make-resolved-id
-                                                                                                               make-binding-wrap
-                                                                                                               store-import-binding
-                                                                                                               lookup-import-binding-name
-                                                                                                               extend-ribcage-subst!
-                                                                                                               extend-ribcage-barrier-help!
-                                                                                                               extend-ribcage-barrier!
-                                                                                                               import-extend-ribcage!
-                                                                                                               extend-ribcage!
-                                                                                                               make-empty-ribcage
-                                                                                                               barrier-marker
-                                                                                                               new-mark
-                                                                                                               anti-mark
-                                                                                                               the-anti-mark
-                                                                                                               set-env-wrap!
-                                                                                                               set-env-top-ribcage!
-                                                                                                               env-wrap
-                                                                                                               env-top-ribcage
-                                                                                                               env?
-                                                                                                               make-env
-                                                                                                               set-import-interface-new-marks!
-                                                                                                               set-import-interface-interface!
-                                                                                                               import-interface-new-marks
-                                                                                                               import-interface-interface
-                                                                                                               import-interface?
-                                                                                                               make-import-interface
-                                                                                                               set-top-ribcage-mutable?!
-                                                                                                               set-top-ribcage-key!
-                                                                                                               top-ribcage-mutable?
-                                                                                                               top-ribcage-key
-                                                                                                               top-ribcage?
-                                                                                                               make-top-ribcage
-                                                                                                               set-ribcage-labels!
-                                                                                                               set-ribcage-marks!
-                                                                                                               set-ribcage-symnames!
-                                                                                                               ribcage-labels
-                                                                                                               ribcage-marks
-                                                                                                               ribcage-symnames
-                                                                                                               ribcage?
-                                                                                                               make-ribcage
-                                                                                                               gen-labels
-                                                                                                               label?
-                                                                                                               gen-label
-                                                                                                               set-indirect-label!
-                                                                                                               get-indirect-label
-                                                                                                               indirect-label?
-                                                                                                               gen-indirect-label
-                                                                                                               anon
-                                                                                                               only-top-marked?
-                                                                                                               top-marked?
-                                                                                                               top-wrap
-                                                                                                               empty-wrap
-                                                                                                               wrap-subst
-                                                                                                               wrap-marks
-                                                                                                               make-wrap
-                                                                                                               id-sym-name&marks
-                                                                                                               id-subst
-                                                                                                               id-marks
-                                                                                                               id-sym-name
-                                                                                                               id?
-                                                                                                               nonsymbol-id?
-                                                                                                               global-extend
-                                                                                                               defer-or-eval-transformer
-                                                                                                               make-transformer-binding
-                                                                                                               lookup
-                                                                                                               lookup*
-                                                                                                               displaced-lexical-error
-                                                                                                               displaced-lexical?
-                                                                                                               extend-var-env*
-                                                                                                               extend-env*
-                                                                                                               extend-env
-                                                                                                               null-env
-                                                                                                               binding?
-                                                                                                               set-binding-value!
-                                                                                                               set-binding-type!
-                                                                                                               binding-value
-                                                                                                               binding-type
-                                                                                                               make-binding
-                                                                                                               sanitize-binding
-                                                                                                               arg-check
-                                                                                                               no-source
-                                                                                                               unannotate
-                                                                                                               self-evaluating?
-                                                                                                               lexical-var?
-                                                                                                               build-lexical-var
-                                                                                                               build-top-module
-                                                                                                               build-body
-                                                                                                               build-letrec
-                                                                                                               build-sequence
-                                                                                                               build-data
-                                                                                                               build-primref
-                                                                                                               built-lambda?
-                                                                                                               build-lambda
-                                                                                                               build-revisit-only
-                                                                                                               build-visit-only
-                                                                                                               build-cte-install
-                                                                                                               build-global-definition
-                                                                                                               build-global-assignment
-                                                                                                               build-global-reference
-                                                                                                               build-lexical-assignment
-                                                                                                               build-lexical-reference
-                                                                                                               build-conditional
-                                                                                                               build-application
-                                                                                                               generate-id
-                                                                                                               put-import-binding
-                                                                                                               get-import-binding
-                                                                                                               read-only-binding?
-                                                                                                               put-global-definition-hook
-                                                                                                               get-global-definition-hook
-                                                                                                               put-cte-hook
-                                                                                                               gensym-hook
-                                                                                                               error-hook
-                                                                                                               define-top-level-value-hook
-                                                                                                               local-eval-hook
-                                                                                                               top-level-eval-hook
-                                                                                                               annotation?
-                                                                                                               set-syntax-object-wrap!
-                                                                                                               set-syntax-object-expression!
-                                                                                                               syntax-object-wrap
-                                                                                                               syntax-object-expression
-                                                                                                               syntax-object?
-                                                                                                               make-syntax-object
-                                                                                                               noexpand
-                                                                                                               let-values
-                                                                                                               define-structure
-                                                                                                               unless
-                                                                                                               when)
-                                                                                                              ((top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               ("m" top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               ("m" top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top)
-                                                                                                               (top))
-                                                                                                              ("i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"
-                                                                                                               "i"))
-                                                                                                            #(top-ribcage
-                                                                                                              *top*
-                                                                                                              #t)))
-                                                                                                       g847
-                                                                                                       g848
-                                                                                                       g861))
-                                                                                                   (if g844
-                                                                                                       g854
-                                                                                                       '#f))])
-                                                                                              g859)
-                                                                                            (#%syntax-error
-                                                                                              g858))])
-                                                                                      (#%$syntax-dispatch
-                                                                                        g858
-                                                                                        '(any any)))])
-                                                                                  ((top-level-value
-                                                                                     'list)
-                                                                                    g856
-                                                                                    (g815
-                                                                                      g855)))]))])
-                                                                        g850)
-                                                                      ((case-lambda
-                                                                         [(g862)
-                                                                          (if (if g862
-                                                                                  (#%apply
-                                                                                    (case-lambda
-                                                                                      [(g863
-                                                                                        g864)
-                                                                                       ((top-level-value
-                                                                                          'andmap)
-                                                                                         (top-level-value
-                                                                                           'identifier?)
-                                                                                         g864)])
-                                                                                    g862)
-                                                                                  '#f)
-                                                                              (#%apply
-                                                                                (case-lambda
-                                                                                  [(g865
-                                                                                    g866)
-                                                                                   ((top-level-value
-                                                                                      'call-with-values)
-                                                                                     (case-lambda
-                                                                                       [()
-                                                                                        (g816
-                                                                                          g865
-                                                                                          '#t)])
-                                                                                     (case-lambda
-                                                                                       [(g867
-                                                                                         g868
-                                                                                         g869)
-                                                                                        ((case-lambda
-                                                                                           [(g870)
-                                                                                            ((case-lambda
-                                                                                               [(g871)
-                                                                                                (if g871
-                                                                                                    (#%apply
-                                                                                                      (case-lambda
-                                                                                                        [(g872
-                                                                                                          g873
-                                                                                                          g874)
-                                                                                                         ((top-level-value
-                                                                                                            'values)
-                                                                                                           g867
-                                                                                                           (#%list
-                                                                                                             '#(syntax-object
-                                                                                                                begin
-                                                                                                                ((top)
-                                                                                                                  #(ribcage
-                                                                                                                    #(d
-                                                                                                                      tmid
-                                                                                                                      id)
-                                                                                                                    #((top)
-                                                                                                                      (top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ()
-                                                                                                                    ()
-                                                                                                                    ())
-                                                                                                                  #(ribcage
-                                                                                                                    #(mid
-                                                                                                                      d
-                                                                                                                      exports)
-                                                                                                                    #((top)
-                                                                                                                      (top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    #(m
-                                                                                                                      id)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    #(orig
-                                                                                                                      import-only?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ()
-                                                                                                                    ()
-                                                                                                                    ())
-                                                                                                                  #(ribcage
-                                                                                                                    #(m
-                                                                                                                      exports?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    (modspec*
-                                                                                                                      modspec
-                                                                                                                      gen-mid
-                                                                                                                      prefix-drop
-                                                                                                                      prefix-add
-                                                                                                                      difference)
-                                                                                                                    ((top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top))
-                                                                                                                    ("i" "i"
-                                                                                                                         "i"
-                                                                                                                         "i"
-                                                                                                                         "i"
-                                                                                                                         "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    #(r)
-                                                                                                                    #((top))
-                                                                                                                    #("i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ()
-                                                                                                                    ()
-                                                                                                                    ())
-                                                                                                                  #(ribcage
-                                                                                                                    #(orig
-                                                                                                                      import-only?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ($import-help
-                                                                                                                      $module-exports)
-                                                                                                                    ((top)
-                                                                                                                      (top))
-                                                                                                                    ("i" "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    (lambda-var-list
-                                                                                                                     gen-var
-                                                                                                                     strip
-                                                                                                                     strip*
-                                                                                                                     strip-annotation
-                                                                                                                     ellipsis?
-                                                                                                                     chi-void
-                                                                                                                     chi-local-syntax
-                                                                                                                     chi-lambda-clause
-                                                                                                                     parse-begin
-                                                                                                                     parse-alias
-                                                                                                                     parse-eval-when
-                                                                                                                     parse-meta
-                                                                                                                     parse-define-syntax
-                                                                                                                     parse-define
-                                                                                                                     parse-import
-                                                                                                                     parse-module
-                                                                                                                     do-import!
-                                                                                                                     lookup-import-label
-                                                                                                                     import-mark-delta
-                                                                                                                     chi-internal
-                                                                                                                     chi-body
-                                                                                                                     chi-macro
-                                                                                                                     chi-set!
-                                                                                                                     chi-application
-                                                                                                                     chi-expr
-                                                                                                                     chi
-                                                                                                                     chi-sequence
-                                                                                                                     chi-meta-frob
-                                                                                                                     chi-frobs
-                                                                                                                     ct-eval/residualize3
-                                                                                                                     ct-eval/residualize2
-                                                                                                                     rt-eval/residualize
-                                                                                                                     initial-mode-set
-                                                                                                                     update-mode-set
-                                                                                                                     do-top-import
-                                                                                                                     vfor-each
-                                                                                                                     vmap
-                                                                                                                     chi-external
-                                                                                                                     check-defined-ids
-                                                                                                                     check-module-exports
-                                                                                                                     id-set-diff
-                                                                                                                     chi-top-module
-                                                                                                                     set-frob-meta?!
-                                                                                                                     set-frob-e!
-                                                                                                                     frob-meta?
-                                                                                                                     frob-e
-                                                                                                                     frob?
-                                                                                                                     make-frob
-                                                                                                                     create-module-binding
-                                                                                                                     set-module-binding-exported!
-                                                                                                                     set-module-binding-val!
-                                                                                                                     set-module-binding-imps!
-                                                                                                                     set-module-binding-label!
-                                                                                                                     set-module-binding-id!
-                                                                                                                     set-module-binding-type!
-                                                                                                                     module-binding-exported
-                                                                                                                     module-binding-val
-                                                                                                                     module-binding-imps
-                                                                                                                     module-binding-label
-                                                                                                                     module-binding-id
-                                                                                                                     module-binding-type
-                                                                                                                     module-binding?
-                                                                                                                     make-module-binding
-                                                                                                                     make-resolved-interface
-                                                                                                                     make-unresolved-interface
-                                                                                                                     set-interface-token!
-                                                                                                                     set-interface-exports!
-                                                                                                                     set-interface-marks!
-                                                                                                                     interface-token
-                                                                                                                     interface-exports
-                                                                                                                     interface-marks
-                                                                                                                     interface?
-                                                                                                                     make-interface
-                                                                                                                     flatten-exports
-                                                                                                                     chi-top
-                                                                                                                     chi-top-sequence
-                                                                                                                     chi-top*
-                                                                                                                     syntax-type
-                                                                                                                     chi-when-list
-                                                                                                                     source-wrap
-                                                                                                                     wrap
-                                                                                                                     bound-id-member?
-                                                                                                                     invalid-ids-error
-                                                                                                                     distinct-bound-ids?
-                                                                                                                     valid-bound-ids?
-                                                                                                                     bound-id=?
-                                                                                                                     help-bound-id=?
-                                                                                                                     literal-id=?
-                                                                                                                     free-id=?
-                                                                                                                     id-var-name
-                                                                                                                     id-var-name-loc
-                                                                                                                     id-var-name&marks
-                                                                                                                     id-var-name-loc&marks
-                                                                                                                     top-id-free-var-name
-                                                                                                                     top-id-bound-var-name
-                                                                                                                     anon
-                                                                                                                     diff-marks
-                                                                                                                     same-marks?
-                                                                                                                     join-subst
-                                                                                                                     join-marks
-                                                                                                                     join-wraps
-                                                                                                                     smart-append
-                                                                                                                     resolved-id-var-name
-                                                                                                                     id->resolved-id
-                                                                                                                     make-resolved-id
-                                                                                                                     make-binding-wrap
-                                                                                                                     store-import-binding
-                                                                                                                     lookup-import-binding-name
-                                                                                                                     extend-ribcage-subst!
-                                                                                                                     extend-ribcage-barrier-help!
-                                                                                                                     extend-ribcage-barrier!
-                                                                                                                     import-extend-ribcage!
-                                                                                                                     extend-ribcage!
-                                                                                                                     make-empty-ribcage
-                                                                                                                     barrier-marker
-                                                                                                                     new-mark
-                                                                                                                     anti-mark
-                                                                                                                     the-anti-mark
-                                                                                                                     set-env-wrap!
-                                                                                                                     set-env-top-ribcage!
-                                                                                                                     env-wrap
-                                                                                                                     env-top-ribcage
-                                                                                                                     env?
-                                                                                                                     make-env
-                                                                                                                     set-import-interface-new-marks!
-                                                                                                                     set-import-interface-interface!
-                                                                                                                     import-interface-new-marks
-                                                                                                                     import-interface-interface
-                                                                                                                     import-interface?
-                                                                                                                     make-import-interface
-                                                                                                                     set-top-ribcage-mutable?!
-                                                                                                                     set-top-ribcage-key!
-                                                                                                                     top-ribcage-mutable?
-                                                                                                                     top-ribcage-key
-                                                                                                                     top-ribcage?
-                                                                                                                     make-top-ribcage
-                                                                                                                     set-ribcage-labels!
-                                                                                                                     set-ribcage-marks!
-                                                                                                                     set-ribcage-symnames!
-                                                                                                                     ribcage-labels
-                                                                                                                     ribcage-marks
-                                                                                                                     ribcage-symnames
-                                                                                                                     ribcage?
-                                                                                                                     make-ribcage
-                                                                                                                     gen-labels
-                                                                                                                     label?
-                                                                                                                     gen-label
-                                                                                                                     set-indirect-label!
-                                                                                                                     get-indirect-label
-                                                                                                                     indirect-label?
-                                                                                                                     gen-indirect-label
-                                                                                                                     anon
-                                                                                                                     only-top-marked?
-                                                                                                                     top-marked?
-                                                                                                                     top-wrap
-                                                                                                                     empty-wrap
-                                                                                                                     wrap-subst
-                                                                                                                     wrap-marks
-                                                                                                                     make-wrap
-                                                                                                                     id-sym-name&marks
-                                                                                                                     id-subst
-                                                                                                                     id-marks
-                                                                                                                     id-sym-name
-                                                                                                                     id?
-                                                                                                                     nonsymbol-id?
-                                                                                                                     global-extend
-                                                                                                                     defer-or-eval-transformer
-                                                                                                                     make-transformer-binding
-                                                                                                                     lookup
-                                                                                                                     lookup*
-                                                                                                                     displaced-lexical-error
-                                                                                                                     displaced-lexical?
-                                                                                                                     extend-var-env*
-                                                                                                                     extend-env*
-                                                                                                                     extend-env
-                                                                                                                     null-env
-                                                                                                                     binding?
-                                                                                                                     set-binding-value!
-                                                                                                                     set-binding-type!
-                                                                                                                     binding-value
-                                                                                                                     binding-type
-                                                                                                                     make-binding
-                                                                                                                     sanitize-binding
-                                                                                                                     arg-check
-                                                                                                                     no-source
-                                                                                                                     unannotate
-                                                                                                                     self-evaluating?
-                                                                                                                     lexical-var?
-                                                                                                                     build-lexical-var
-                                                                                                                     build-top-module
-                                                                                                                     build-body
-                                                                                                                     build-letrec
-                                                                                                                     build-sequence
-                                                                                                                     build-data
-                                                                                                                     build-primref
-                                                                                                                     built-lambda?
-                                                                                                                     build-lambda
-                                                                                                                     build-revisit-only
-                                                                                                                     build-visit-only
-                                                                                                                     build-cte-install
-                                                                                                                     build-global-definition
-                                                                                                                     build-global-assignment
-                                                                                                                     build-global-reference
-                                                                                                                     build-lexical-assignment
-                                                                                                                     build-lexical-reference
-                                                                                                                     build-conditional
-                                                                                                                     build-application
-                                                                                                                     generate-id
-                                                                                                                     put-import-binding
-                                                                                                                     get-import-binding
-                                                                                                                     read-only-binding?
-                                                                                                                     put-global-definition-hook
-                                                                                                                     get-global-definition-hook
-                                                                                                                     put-cte-hook
-                                                                                                                     gensym-hook
-                                                                                                                     error-hook
-                                                                                                                     define-top-level-value-hook
-                                                                                                                     local-eval-hook
-                                                                                                                     top-level-eval-hook
-                                                                                                                     annotation?
-                                                                                                                     set-syntax-object-wrap!
-                                                                                                                     set-syntax-object-expression!
-                                                                                                                     syntax-object-wrap
-                                                                                                                     syntax-object-expression
-                                                                                                                     syntax-object?
-                                                                                                                     make-syntax-object
-                                                                                                                     noexpand
-                                                                                                                     let-values
-                                                                                                                     define-structure
-                                                                                                                     unless
-                                                                                                                     when)
-                                                                                                                    ((top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     ("m" top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     ("m" top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top))
-                                                                                                                    ("i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"))
-                                                                                                                  #(top-ribcage
-                                                                                                                    *top*
-                                                                                                                    #t)))
-                                                                                                             (#%list
-                                                                                                               '#(syntax-object
-                                                                                                                  $module
-                                                                                                                  ((top)
-                                                                                                                    #(ribcage
-                                                                                                                      #(d
-                                                                                                                        tmid
-                                                                                                                        id)
-                                                                                                                      #((top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(mid
-                                                                                                                        d
-                                                                                                                        exports)
-                                                                                                                      #((top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(m
-                                                                                                                        id)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(orig
-                                                                                                                        import-only?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(m
-                                                                                                                        exports?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      (modspec*
-                                                                                                                        modspec
-                                                                                                                        gen-mid
-                                                                                                                        prefix-drop
-                                                                                                                        prefix-add
-                                                                                                                        difference)
-                                                                                                                      ((top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      ("i" "i"
-                                                                                                                           "i"
-                                                                                                                           "i"
-                                                                                                                           "i"
-                                                                                                                           "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(r)
-                                                                                                                      #((top))
-                                                                                                                      #("i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(orig
-                                                                                                                        import-only?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ($import-help
-                                                                                                                        $module-exports)
-                                                                                                                      ((top)
-                                                                                                                        (top))
-                                                                                                                      ("i" "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      (lambda-var-list
-                                                                                                                       gen-var
-                                                                                                                       strip
-                                                                                                                       strip*
-                                                                                                                       strip-annotation
-                                                                                                                       ellipsis?
-                                                                                                                       chi-void
-                                                                                                                       chi-local-syntax
-                                                                                                                       chi-lambda-clause
-                                                                                                                       parse-begin
-                                                                                                                       parse-alias
-                                                                                                                       parse-eval-when
-                                                                                                                       parse-meta
-                                                                                                                       parse-define-syntax
-                                                                                                                       parse-define
-                                                                                                                       parse-import
-                                                                                                                       parse-module
-                                                                                                                       do-import!
-                                                                                                                       lookup-import-label
-                                                                                                                       import-mark-delta
-                                                                                                                       chi-internal
-                                                                                                                       chi-body
-                                                                                                                       chi-macro
-                                                                                                                       chi-set!
-                                                                                                                       chi-application
-                                                                                                                       chi-expr
-                                                                                                                       chi
-                                                                                                                       chi-sequence
-                                                                                                                       chi-meta-frob
-                                                                                                                       chi-frobs
-                                                                                                                       ct-eval/residualize3
-                                                                                                                       ct-eval/residualize2
-                                                                                                                       rt-eval/residualize
-                                                                                                                       initial-mode-set
-                                                                                                                       update-mode-set
-                                                                                                                       do-top-import
-                                                                                                                       vfor-each
-                                                                                                                       vmap
-                                                                                                                       chi-external
-                                                                                                                       check-defined-ids
-                                                                                                                       check-module-exports
-                                                                                                                       id-set-diff
-                                                                                                                       chi-top-module
-                                                                                                                       set-frob-meta?!
-                                                                                                                       set-frob-e!
-                                                                                                                       frob-meta?
-                                                                                                                       frob-e
-                                                                                                                       frob?
-                                                                                                                       make-frob
-                                                                                                                       create-module-binding
-                                                                                                                       set-module-binding-exported!
-                                                                                                                       set-module-binding-val!
-                                                                                                                       set-module-binding-imps!
-                                                                                                                       set-module-binding-label!
-                                                                                                                       set-module-binding-id!
-                                                                                                                       set-module-binding-type!
-                                                                                                                       module-binding-exported
-                                                                                                                       module-binding-val
-                                                                                                                       module-binding-imps
-                                                                                                                       module-binding-label
-                                                                                                                       module-binding-id
-                                                                                                                       module-binding-type
-                                                                                                                       module-binding?
-                                                                                                                       make-module-binding
-                                                                                                                       make-resolved-interface
-                                                                                                                       make-unresolved-interface
-                                                                                                                       set-interface-token!
-                                                                                                                       set-interface-exports!
-                                                                                                                       set-interface-marks!
-                                                                                                                       interface-token
-                                                                                                                       interface-exports
-                                                                                                                       interface-marks
-                                                                                                                       interface?
-                                                                                                                       make-interface
-                                                                                                                       flatten-exports
-                                                                                                                       chi-top
-                                                                                                                       chi-top-sequence
-                                                                                                                       chi-top*
-                                                                                                                       syntax-type
-                                                                                                                       chi-when-list
-                                                                                                                       source-wrap
-                                                                                                                       wrap
-                                                                                                                       bound-id-member?
-                                                                                                                       invalid-ids-error
-                                                                                                                       distinct-bound-ids?
-                                                                                                                       valid-bound-ids?
-                                                                                                                       bound-id=?
-                                                                                                                       help-bound-id=?
-                                                                                                                       literal-id=?
-                                                                                                                       free-id=?
-                                                                                                                       id-var-name
-                                                                                                                       id-var-name-loc
-                                                                                                                       id-var-name&marks
-                                                                                                                       id-var-name-loc&marks
-                                                                                                                       top-id-free-var-name
-                                                                                                                       top-id-bound-var-name
-                                                                                                                       anon
-                                                                                                                       diff-marks
-                                                                                                                       same-marks?
-                                                                                                                       join-subst
-                                                                                                                       join-marks
-                                                                                                                       join-wraps
-                                                                                                                       smart-append
-                                                                                                                       resolved-id-var-name
-                                                                                                                       id->resolved-id
-                                                                                                                       make-resolved-id
-                                                                                                                       make-binding-wrap
-                                                                                                                       store-import-binding
-                                                                                                                       lookup-import-binding-name
-                                                                                                                       extend-ribcage-subst!
-                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                       extend-ribcage-barrier!
-                                                                                                                       import-extend-ribcage!
-                                                                                                                       extend-ribcage!
-                                                                                                                       make-empty-ribcage
-                                                                                                                       barrier-marker
-                                                                                                                       new-mark
-                                                                                                                       anti-mark
-                                                                                                                       the-anti-mark
-                                                                                                                       set-env-wrap!
-                                                                                                                       set-env-top-ribcage!
-                                                                                                                       env-wrap
-                                                                                                                       env-top-ribcage
-                                                                                                                       env?
-                                                                                                                       make-env
-                                                                                                                       set-import-interface-new-marks!
-                                                                                                                       set-import-interface-interface!
-                                                                                                                       import-interface-new-marks
-                                                                                                                       import-interface-interface
-                                                                                                                       import-interface?
-                                                                                                                       make-import-interface
-                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                       set-top-ribcage-key!
-                                                                                                                       top-ribcage-mutable?
-                                                                                                                       top-ribcage-key
-                                                                                                                       top-ribcage?
-                                                                                                                       make-top-ribcage
-                                                                                                                       set-ribcage-labels!
-                                                                                                                       set-ribcage-marks!
-                                                                                                                       set-ribcage-symnames!
-                                                                                                                       ribcage-labels
-                                                                                                                       ribcage-marks
-                                                                                                                       ribcage-symnames
-                                                                                                                       ribcage?
-                                                                                                                       make-ribcage
-                                                                                                                       gen-labels
-                                                                                                                       label?
-                                                                                                                       gen-label
-                                                                                                                       set-indirect-label!
-                                                                                                                       get-indirect-label
-                                                                                                                       indirect-label?
-                                                                                                                       gen-indirect-label
-                                                                                                                       anon
-                                                                                                                       only-top-marked?
-                                                                                                                       top-marked?
-                                                                                                                       top-wrap
-                                                                                                                       empty-wrap
-                                                                                                                       wrap-subst
-                                                                                                                       wrap-marks
-                                                                                                                       make-wrap
-                                                                                                                       id-sym-name&marks
-                                                                                                                       id-subst
-                                                                                                                       id-marks
-                                                                                                                       id-sym-name
-                                                                                                                       id?
-                                                                                                                       nonsymbol-id?
-                                                                                                                       global-extend
-                                                                                                                       defer-or-eval-transformer
-                                                                                                                       make-transformer-binding
-                                                                                                                       lookup
-                                                                                                                       lookup*
-                                                                                                                       displaced-lexical-error
-                                                                                                                       displaced-lexical?
-                                                                                                                       extend-var-env*
-                                                                                                                       extend-env*
-                                                                                                                       extend-env
-                                                                                                                       null-env
-                                                                                                                       binding?
-                                                                                                                       set-binding-value!
-                                                                                                                       set-binding-type!
-                                                                                                                       binding-value
-                                                                                                                       binding-type
-                                                                                                                       make-binding
-                                                                                                                       sanitize-binding
-                                                                                                                       arg-check
-                                                                                                                       no-source
-                                                                                                                       unannotate
-                                                                                                                       self-evaluating?
-                                                                                                                       lexical-var?
-                                                                                                                       build-lexical-var
-                                                                                                                       build-top-module
-                                                                                                                       build-body
-                                                                                                                       build-letrec
-                                                                                                                       build-sequence
-                                                                                                                       build-data
-                                                                                                                       build-primref
-                                                                                                                       built-lambda?
-                                                                                                                       build-lambda
-                                                                                                                       build-revisit-only
-                                                                                                                       build-visit-only
-                                                                                                                       build-cte-install
-                                                                                                                       build-global-definition
-                                                                                                                       build-global-assignment
-                                                                                                                       build-global-reference
-                                                                                                                       build-lexical-assignment
-                                                                                                                       build-lexical-reference
-                                                                                                                       build-conditional
-                                                                                                                       build-application
-                                                                                                                       generate-id
-                                                                                                                       put-import-binding
-                                                                                                                       get-import-binding
-                                                                                                                       read-only-binding?
-                                                                                                                       put-global-definition-hook
-                                                                                                                       get-global-definition-hook
-                                                                                                                       put-cte-hook
-                                                                                                                       gensym-hook
-                                                                                                                       error-hook
-                                                                                                                       define-top-level-value-hook
-                                                                                                                       local-eval-hook
-                                                                                                                       top-level-eval-hook
-                                                                                                                       annotation?
-                                                                                                                       set-syntax-object-wrap!
-                                                                                                                       set-syntax-object-expression!
-                                                                                                                       syntax-object-wrap
-                                                                                                                       syntax-object-expression
-                                                                                                                       syntax-object?
-                                                                                                                       make-syntax-object
-                                                                                                                       noexpand
-                                                                                                                       let-values
-                                                                                                                       define-structure
-                                                                                                                       unless
-                                                                                                                       when)
-                                                                                                                      ((top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       ("m" top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       ("m" top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top))
-                                                                                                                      ("i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"))
-                                                                                                                    #(top-ribcage
-                                                                                                                      *top*
-                                                                                                                      #t)))
-                                                                                                               g847
-                                                                                                               g873
-                                                                                                               g874
-                                                                                                               g872)
-                                                                                                             (#%list
-                                                                                                               '#(syntax-object
-                                                                                                                  $import
-                                                                                                                  ((top)
-                                                                                                                    #(ribcage
-                                                                                                                      #(d
-                                                                                                                        tmid
-                                                                                                                        id)
-                                                                                                                      #((top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(mid
-                                                                                                                        d
-                                                                                                                        exports)
-                                                                                                                      #((top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(m
-                                                                                                                        id)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(orig
-                                                                                                                        import-only?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(m
-                                                                                                                        exports?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      (modspec*
-                                                                                                                        modspec
-                                                                                                                        gen-mid
-                                                                                                                        prefix-drop
-                                                                                                                        prefix-add
-                                                                                                                        difference)
-                                                                                                                      ((top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top)
-                                                                                                                        (top))
-                                                                                                                      ("i" "i"
-                                                                                                                           "i"
-                                                                                                                           "i"
-                                                                                                                           "i"
-                                                                                                                           "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      #(r)
-                                                                                                                      #((top))
-                                                                                                                      #("i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ()
-                                                                                                                      ()
-                                                                                                                      ())
-                                                                                                                    #(ribcage
-                                                                                                                      #(orig
-                                                                                                                        import-only?)
-                                                                                                                      #((top)
-                                                                                                                        (top))
-                                                                                                                      #("i"
-                                                                                                                        "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      ($import-help
-                                                                                                                        $module-exports)
-                                                                                                                      ((top)
-                                                                                                                        (top))
-                                                                                                                      ("i" "i"))
-                                                                                                                    #(ribcage
-                                                                                                                      (lambda-var-list
-                                                                                                                       gen-var
-                                                                                                                       strip
-                                                                                                                       strip*
-                                                                                                                       strip-annotation
-                                                                                                                       ellipsis?
-                                                                                                                       chi-void
-                                                                                                                       chi-local-syntax
-                                                                                                                       chi-lambda-clause
-                                                                                                                       parse-begin
-                                                                                                                       parse-alias
-                                                                                                                       parse-eval-when
-                                                                                                                       parse-meta
-                                                                                                                       parse-define-syntax
-                                                                                                                       parse-define
-                                                                                                                       parse-import
-                                                                                                                       parse-module
-                                                                                                                       do-import!
-                                                                                                                       lookup-import-label
-                                                                                                                       import-mark-delta
-                                                                                                                       chi-internal
-                                                                                                                       chi-body
-                                                                                                                       chi-macro
-                                                                                                                       chi-set!
-                                                                                                                       chi-application
-                                                                                                                       chi-expr
-                                                                                                                       chi
-                                                                                                                       chi-sequence
-                                                                                                                       chi-meta-frob
-                                                                                                                       chi-frobs
-                                                                                                                       ct-eval/residualize3
-                                                                                                                       ct-eval/residualize2
-                                                                                                                       rt-eval/residualize
-                                                                                                                       initial-mode-set
-                                                                                                                       update-mode-set
-                                                                                                                       do-top-import
-                                                                                                                       vfor-each
-                                                                                                                       vmap
-                                                                                                                       chi-external
-                                                                                                                       check-defined-ids
-                                                                                                                       check-module-exports
-                                                                                                                       id-set-diff
-                                                                                                                       chi-top-module
-                                                                                                                       set-frob-meta?!
-                                                                                                                       set-frob-e!
-                                                                                                                       frob-meta?
-                                                                                                                       frob-e
-                                                                                                                       frob?
-                                                                                                                       make-frob
-                                                                                                                       create-module-binding
-                                                                                                                       set-module-binding-exported!
-                                                                                                                       set-module-binding-val!
-                                                                                                                       set-module-binding-imps!
-                                                                                                                       set-module-binding-label!
-                                                                                                                       set-module-binding-id!
-                                                                                                                       set-module-binding-type!
-                                                                                                                       module-binding-exported
-                                                                                                                       module-binding-val
-                                                                                                                       module-binding-imps
-                                                                                                                       module-binding-label
-                                                                                                                       module-binding-id
-                                                                                                                       module-binding-type
-                                                                                                                       module-binding?
-                                                                                                                       make-module-binding
-                                                                                                                       make-resolved-interface
-                                                                                                                       make-unresolved-interface
-                                                                                                                       set-interface-token!
-                                                                                                                       set-interface-exports!
-                                                                                                                       set-interface-marks!
-                                                                                                                       interface-token
-                                                                                                                       interface-exports
-                                                                                                                       interface-marks
-                                                                                                                       interface?
-                                                                                                                       make-interface
-                                                                                                                       flatten-exports
-                                                                                                                       chi-top
-                                                                                                                       chi-top-sequence
-                                                                                                                       chi-top*
-                                                                                                                       syntax-type
-                                                                                                                       chi-when-list
-                                                                                                                       source-wrap
-                                                                                                                       wrap
-                                                                                                                       bound-id-member?
-                                                                                                                       invalid-ids-error
-                                                                                                                       distinct-bound-ids?
-                                                                                                                       valid-bound-ids?
-                                                                                                                       bound-id=?
-                                                                                                                       help-bound-id=?
-                                                                                                                       literal-id=?
-                                                                                                                       free-id=?
-                                                                                                                       id-var-name
-                                                                                                                       id-var-name-loc
-                                                                                                                       id-var-name&marks
-                                                                                                                       id-var-name-loc&marks
-                                                                                                                       top-id-free-var-name
-                                                                                                                       top-id-bound-var-name
-                                                                                                                       anon
-                                                                                                                       diff-marks
-                                                                                                                       same-marks?
-                                                                                                                       join-subst
-                                                                                                                       join-marks
-                                                                                                                       join-wraps
-                                                                                                                       smart-append
-                                                                                                                       resolved-id-var-name
-                                                                                                                       id->resolved-id
-                                                                                                                       make-resolved-id
-                                                                                                                       make-binding-wrap
-                                                                                                                       store-import-binding
-                                                                                                                       lookup-import-binding-name
-                                                                                                                       extend-ribcage-subst!
-                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                       extend-ribcage-barrier!
-                                                                                                                       import-extend-ribcage!
-                                                                                                                       extend-ribcage!
-                                                                                                                       make-empty-ribcage
-                                                                                                                       barrier-marker
-                                                                                                                       new-mark
-                                                                                                                       anti-mark
-                                                                                                                       the-anti-mark
-                                                                                                                       set-env-wrap!
-                                                                                                                       set-env-top-ribcage!
-                                                                                                                       env-wrap
-                                                                                                                       env-top-ribcage
-                                                                                                                       env?
-                                                                                                                       make-env
-                                                                                                                       set-import-interface-new-marks!
-                                                                                                                       set-import-interface-interface!
-                                                                                                                       import-interface-new-marks
-                                                                                                                       import-interface-interface
-                                                                                                                       import-interface?
-                                                                                                                       make-import-interface
-                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                       set-top-ribcage-key!
-                                                                                                                       top-ribcage-mutable?
-                                                                                                                       top-ribcage-key
-                                                                                                                       top-ribcage?
-                                                                                                                       make-top-ribcage
-                                                                                                                       set-ribcage-labels!
-                                                                                                                       set-ribcage-marks!
-                                                                                                                       set-ribcage-symnames!
-                                                                                                                       ribcage-labels
-                                                                                                                       ribcage-marks
-                                                                                                                       ribcage-symnames
-                                                                                                                       ribcage?
-                                                                                                                       make-ribcage
-                                                                                                                       gen-labels
-                                                                                                                       label?
-                                                                                                                       gen-label
-                                                                                                                       set-indirect-label!
-                                                                                                                       get-indirect-label
-                                                                                                                       indirect-label?
-                                                                                                                       gen-indirect-label
-                                                                                                                       anon
-                                                                                                                       only-top-marked?
-                                                                                                                       top-marked?
-                                                                                                                       top-wrap
-                                                                                                                       empty-wrap
-                                                                                                                       wrap-subst
-                                                                                                                       wrap-marks
-                                                                                                                       make-wrap
-                                                                                                                       id-sym-name&marks
-                                                                                                                       id-subst
-                                                                                                                       id-marks
-                                                                                                                       id-sym-name
-                                                                                                                       id?
-                                                                                                                       nonsymbol-id?
-                                                                                                                       global-extend
-                                                                                                                       defer-or-eval-transformer
-                                                                                                                       make-transformer-binding
-                                                                                                                       lookup
-                                                                                                                       lookup*
-                                                                                                                       displaced-lexical-error
-                                                                                                                       displaced-lexical?
-                                                                                                                       extend-var-env*
-                                                                                                                       extend-env*
-                                                                                                                       extend-env
-                                                                                                                       null-env
-                                                                                                                       binding?
-                                                                                                                       set-binding-value!
-                                                                                                                       set-binding-type!
-                                                                                                                       binding-value
-                                                                                                                       binding-type
-                                                                                                                       make-binding
-                                                                                                                       sanitize-binding
-                                                                                                                       arg-check
-                                                                                                                       no-source
-                                                                                                                       unannotate
-                                                                                                                       self-evaluating?
-                                                                                                                       lexical-var?
-                                                                                                                       build-lexical-var
-                                                                                                                       build-top-module
-                                                                                                                       build-body
-                                                                                                                       build-letrec
-                                                                                                                       build-sequence
-                                                                                                                       build-data
-                                                                                                                       build-primref
-                                                                                                                       built-lambda?
-                                                                                                                       build-lambda
-                                                                                                                       build-revisit-only
-                                                                                                                       build-visit-only
-                                                                                                                       build-cte-install
-                                                                                                                       build-global-definition
-                                                                                                                       build-global-assignment
-                                                                                                                       build-global-reference
-                                                                                                                       build-lexical-assignment
-                                                                                                                       build-lexical-reference
-                                                                                                                       build-conditional
-                                                                                                                       build-application
-                                                                                                                       generate-id
-                                                                                                                       put-import-binding
-                                                                                                                       get-import-binding
-                                                                                                                       read-only-binding?
-                                                                                                                       put-global-definition-hook
-                                                                                                                       get-global-definition-hook
-                                                                                                                       put-cte-hook
-                                                                                                                       gensym-hook
-                                                                                                                       error-hook
-                                                                                                                       define-top-level-value-hook
-                                                                                                                       local-eval-hook
-                                                                                                                       top-level-eval-hook
-                                                                                                                       annotation?
-                                                                                                                       set-syntax-object-wrap!
-                                                                                                                       set-syntax-object-expression!
-                                                                                                                       syntax-object-wrap
-                                                                                                                       syntax-object-expression
-                                                                                                                       syntax-object?
-                                                                                                                       make-syntax-object
-                                                                                                                       noexpand
-                                                                                                                       let-values
-                                                                                                                       define-structure
-                                                                                                                       unless
-                                                                                                                       when)
-                                                                                                                      ((top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       ("m" top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       ("m" top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top)
-                                                                                                                       (top))
-                                                                                                                      ("i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"
-                                                                                                                       "i"))
-                                                                                                                    #(top-ribcage
-                                                                                                                      *top*
-                                                                                                                      #t)))
-                                                                                                               g847
-                                                                                                               g848
-                                                                                                               g873))
-                                                                                                           (if g844
-                                                                                                               g874
-                                                                                                               '#f))])
-                                                                                                      g871)
-                                                                                                    (#%syntax-error
-                                                                                                      g870))])
-                                                                                              (#%$syntax-dispatch
-                                                                                                g870
-                                                                                                '(any any
-                                                                                                      each-any)))])
-                                                                                          ((top-level-value
-                                                                                             'list)
-                                                                                            g868
-                                                                                            (g815
-                                                                                              g867)
-                                                                                            (g812
-                                                                                              g869
-                                                                                              g866)))]))])
-                                                                                g862)
-                                                                              ((case-lambda
-                                                                                 [(g875)
-                                                                                  (if (if g875
-                                                                                          (#%apply
-                                                                                            (case-lambda
-                                                                                              [(g876
-                                                                                                g877)
-                                                                                               ((top-level-value
-                                                                                                  'identifier?)
-                                                                                                 g877)])
-                                                                                            g875)
-                                                                                          '#f)
-                                                                                      (#%apply
-                                                                                        (case-lambda
-                                                                                          [(g878
-                                                                                            g879)
-                                                                                           ((top-level-value
-                                                                                              'call-with-values)
-                                                                                             (case-lambda
-                                                                                               [()
-                                                                                                (g816
-                                                                                                  g878
-                                                                                                  '#t)])
-                                                                                             (case-lambda
-                                                                                               [(g880
-                                                                                                 g881
-                                                                                                 g882)
-                                                                                                ((case-lambda
-                                                                                                   [(g883)
-                                                                                                    ((case-lambda
-                                                                                                       [(g884)
-                                                                                                        (if g884
-                                                                                                            (#%apply
-                                                                                                              (case-lambda
-                                                                                                                [(g885
-                                                                                                                  g886
-                                                                                                                  g887
-                                                                                                                  g888
-                                                                                                                  g889)
-                                                                                                                 ((top-level-value
-                                                                                                                    'values)
-                                                                                                                   g880
-                                                                                                                   (#%list
-                                                                                                                     '#(syntax-object
-                                                                                                                        begin
-                                                                                                                        ((top)
-                                                                                                                          #(ribcage
-                                                                                                                            #(d
-                                                                                                                              tmid
-                                                                                                                              old-id
-                                                                                                                              tmp
-                                                                                                                              id)
-                                                                                                                            #((top)
-                                                                                                                              (top)
-                                                                                                                              (top)
-                                                                                                                              (top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"
-                                                                                                                              "i"
-                                                                                                                              "i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            ()
-                                                                                                                            ()
-                                                                                                                            ())
-                                                                                                                          #(ribcage
-                                                                                                                            #(mid
-                                                                                                                              d
-                                                                                                                              exports)
-                                                                                                                            #((top)
-                                                                                                                              (top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            #(m
-                                                                                                                              prefix-id)
-                                                                                                                            #((top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            #(orig
-                                                                                                                              import-only?)
-                                                                                                                            #((top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            ()
-                                                                                                                            ()
-                                                                                                                            ())
-                                                                                                                          #(ribcage
-                                                                                                                            #(m
-                                                                                                                              exports?)
-                                                                                                                            #((top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            (modspec*
-                                                                                                                              modspec
-                                                                                                                              gen-mid
-                                                                                                                              prefix-drop
-                                                                                                                              prefix-add
-                                                                                                                              difference)
-                                                                                                                            ((top)
-                                                                                                                              (top)
-                                                                                                                              (top)
-                                                                                                                              (top)
-                                                                                                                              (top)
-                                                                                                                              (top))
-                                                                                                                            ("i" "i"
-                                                                                                                                 "i"
-                                                                                                                                 "i"
-                                                                                                                                 "i"
-                                                                                                                                 "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            #(r)
-                                                                                                                            #((top))
-                                                                                                                            #("i"))
-                                                                                                                          #(ribcage
-                                                                                                                            ()
-                                                                                                                            ()
-                                                                                                                            ())
-                                                                                                                          #(ribcage
-                                                                                                                            #(orig
-                                                                                                                              import-only?)
-                                                                                                                            #((top)
-                                                                                                                              (top))
-                                                                                                                            #("i"
-                                                                                                                              "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            ($import-help
-                                                                                                                              $module-exports)
-                                                                                                                            ((top)
-                                                                                                                              (top))
-                                                                                                                            ("i" "i"))
-                                                                                                                          #(ribcage
-                                                                                                                            (lambda-var-list
-                                                                                                                             gen-var
-                                                                                                                             strip
-                                                                                                                             strip*
-                                                                                                                             strip-annotation
-                                                                                                                             ellipsis?
-                                                                                                                             chi-void
-                                                                                                                             chi-local-syntax
-                                                                                                                             chi-lambda-clause
-                                                                                                                             parse-begin
-                                                                                                                             parse-alias
-                                                                                                                             parse-eval-when
-                                                                                                                             parse-meta
-                                                                                                                             parse-define-syntax
-                                                                                                                             parse-define
-                                                                                                                             parse-import
-                                                                                                                             parse-module
-                                                                                                                             do-import!
-                                                                                                                             lookup-import-label
-                                                                                                                             import-mark-delta
-                                                                                                                             chi-internal
-                                                                                                                             chi-body
-                                                                                                                             chi-macro
-                                                                                                                             chi-set!
-                                                                                                                             chi-application
-                                                                                                                             chi-expr
-                                                                                                                             chi
-                                                                                                                             chi-sequence
-                                                                                                                             chi-meta-frob
-                                                                                                                             chi-frobs
-                                                                                                                             ct-eval/residualize3
-                                                                                                                             ct-eval/residualize2
-                                                                                                                             rt-eval/residualize
-                                                                                                                             initial-mode-set
-                                                                                                                             update-mode-set
-                                                                                                                             do-top-import
-                                                                                                                             vfor-each
-                                                                                                                             vmap
-                                                                                                                             chi-external
-                                                                                                                             check-defined-ids
-                                                                                                                             check-module-exports
-                                                                                                                             id-set-diff
-                                                                                                                             chi-top-module
-                                                                                                                             set-frob-meta?!
-                                                                                                                             set-frob-e!
-                                                                                                                             frob-meta?
-                                                                                                                             frob-e
-                                                                                                                             frob?
-                                                                                                                             make-frob
-                                                                                                                             create-module-binding
-                                                                                                                             set-module-binding-exported!
-                                                                                                                             set-module-binding-val!
-                                                                                                                             set-module-binding-imps!
-                                                                                                                             set-module-binding-label!
-                                                                                                                             set-module-binding-id!
-                                                                                                                             set-module-binding-type!
-                                                                                                                             module-binding-exported
-                                                                                                                             module-binding-val
-                                                                                                                             module-binding-imps
-                                                                                                                             module-binding-label
-                                                                                                                             module-binding-id
-                                                                                                                             module-binding-type
-                                                                                                                             module-binding?
-                                                                                                                             make-module-binding
-                                                                                                                             make-resolved-interface
-                                                                                                                             make-unresolved-interface
-                                                                                                                             set-interface-token!
-                                                                                                                             set-interface-exports!
-                                                                                                                             set-interface-marks!
-                                                                                                                             interface-token
-                                                                                                                             interface-exports
-                                                                                                                             interface-marks
-                                                                                                                             interface?
-                                                                                                                             make-interface
-                                                                                                                             flatten-exports
-                                                                                                                             chi-top
-                                                                                                                             chi-top-sequence
-                                                                                                                             chi-top*
-                                                                                                                             syntax-type
-                                                                                                                             chi-when-list
-                                                                                                                             source-wrap
-                                                                                                                             wrap
-                                                                                                                             bound-id-member?
-                                                                                                                             invalid-ids-error
-                                                                                                                             distinct-bound-ids?
-                                                                                                                             valid-bound-ids?
-                                                                                                                             bound-id=?
-                                                                                                                             help-bound-id=?
-                                                                                                                             literal-id=?
-                                                                                                                             free-id=?
-                                                                                                                             id-var-name
-                                                                                                                             id-var-name-loc
-                                                                                                                             id-var-name&marks
-                                                                                                                             id-var-name-loc&marks
-                                                                                                                             top-id-free-var-name
-                                                                                                                             top-id-bound-var-name
-                                                                                                                             anon
-                                                                                                                             diff-marks
-                                                                                                                             same-marks?
-                                                                                                                             join-subst
-                                                                                                                             join-marks
-                                                                                                                             join-wraps
-                                                                                                                             smart-append
-                                                                                                                             resolved-id-var-name
-                                                                                                                             id->resolved-id
-                                                                                                                             make-resolved-id
-                                                                                                                             make-binding-wrap
-                                                                                                                             store-import-binding
-                                                                                                                             lookup-import-binding-name
-                                                                                                                             extend-ribcage-subst!
-                                                                                                                             extend-ribcage-barrier-help!
-                                                                                                                             extend-ribcage-barrier!
-                                                                                                                             import-extend-ribcage!
-                                                                                                                             extend-ribcage!
-                                                                                                                             make-empty-ribcage
-                                                                                                                             barrier-marker
-                                                                                                                             new-mark
-                                                                                                                             anti-mark
-                                                                                                                             the-anti-mark
-                                                                                                                             set-env-wrap!
-                                                                                                                             set-env-top-ribcage!
-                                                                                                                             env-wrap
-                                                                                                                             env-top-ribcage
-                                                                                                                             env?
-                                                                                                                             make-env
-                                                                                                                             set-import-interface-new-marks!
-                                                                                                                             set-import-interface-interface!
-                                                                                                                             import-interface-new-marks
-                                                                                                                             import-interface-interface
-                                                                                                                             import-interface?
-                                                                                                                             make-import-interface
-                                                                                                                             set-top-ribcage-mutable?!
-                                                                                                                             set-top-ribcage-key!
-                                                                                                                             top-ribcage-mutable?
-                                                                                                                             top-ribcage-key
-                                                                                                                             top-ribcage?
-                                                                                                                             make-top-ribcage
-                                                                                                                             set-ribcage-labels!
-                                                                                                                             set-ribcage-marks!
-                                                                                                                             set-ribcage-symnames!
-                                                                                                                             ribcage-labels
-                                                                                                                             ribcage-marks
-                                                                                                                             ribcage-symnames
-                                                                                                                             ribcage?
-                                                                                                                             make-ribcage
-                                                                                                                             gen-labels
-                                                                                                                             label?
-                                                                                                                             gen-label
-                                                                                                                             set-indirect-label!
-                                                                                                                             get-indirect-label
-                                                                                                                             indirect-label?
-                                                                                                                             gen-indirect-label
-                                                                                                                             anon
-                                                                                                                             only-top-marked?
-                                                                                                                             top-marked?
-                                                                                                                             top-wrap
-                                                                                                                             empty-wrap
-                                                                                                                             wrap-subst
-                                                                                                                             wrap-marks
-                                                                                                                             make-wrap
-                                                                                                                             id-sym-name&marks
-                                                                                                                             id-subst
-                                                                                                                             id-marks
-                                                                                                                             id-sym-name
-                                                                                                                             id?
-                                                                                                                             nonsymbol-id?
-                                                                                                                             global-extend
-                                                                                                                             defer-or-eval-transformer
-                                                                                                                             make-transformer-binding
-                                                                                                                             lookup
-                                                                                                                             lookup*
-                                                                                                                             displaced-lexical-error
-                                                                                                                             displaced-lexical?
-                                                                                                                             extend-var-env*
-                                                                                                                             extend-env*
-                                                                                                                             extend-env
-                                                                                                                             null-env
-                                                                                                                             binding?
-                                                                                                                             set-binding-value!
-                                                                                                                             set-binding-type!
-                                                                                                                             binding-value
-                                                                                                                             binding-type
-                                                                                                                             make-binding
-                                                                                                                             sanitize-binding
-                                                                                                                             arg-check
-                                                                                                                             no-source
-                                                                                                                             unannotate
-                                                                                                                             self-evaluating?
-                                                                                                                             lexical-var?
-                                                                                                                             build-lexical-var
-                                                                                                                             build-top-module
-                                                                                                                             build-body
-                                                                                                                             build-letrec
-                                                                                                                             build-sequence
-                                                                                                                             build-data
-                                                                                                                             build-primref
-                                                                                                                             built-lambda?
-                                                                                                                             build-lambda
-                                                                                                                             build-revisit-only
-                                                                                                                             build-visit-only
-                                                                                                                             build-cte-install
-                                                                                                                             build-global-definition
-                                                                                                                             build-global-assignment
-                                                                                                                             build-global-reference
-                                                                                                                             build-lexical-assignment
-                                                                                                                             build-lexical-reference
-                                                                                                                             build-conditional
-                                                                                                                             build-application
-                                                                                                                             generate-id
-                                                                                                                             put-import-binding
-                                                                                                                             get-import-binding
-                                                                                                                             read-only-binding?
-                                                                                                                             put-global-definition-hook
-                                                                                                                             get-global-definition-hook
-                                                                                                                             put-cte-hook
-                                                                                                                             gensym-hook
-                                                                                                                             error-hook
-                                                                                                                             define-top-level-value-hook
-                                                                                                                             local-eval-hook
-                                                                                                                             top-level-eval-hook
-                                                                                                                             annotation?
-                                                                                                                             set-syntax-object-wrap!
-                                                                                                                             set-syntax-object-expression!
-                                                                                                                             syntax-object-wrap
-                                                                                                                             syntax-object-expression
-                                                                                                                             syntax-object?
-                                                                                                                             make-syntax-object
-                                                                                                                             noexpand
-                                                                                                                             let-values
-                                                                                                                             define-structure
-                                                                                                                             unless
-                                                                                                                             when)
-                                                                                                                            ((top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             ("m" top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             ("m" top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top)
-                                                                                                                             (top))
-                                                                                                                            ("i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"
-                                                                                                                             "i"))
-                                                                                                                          #(top-ribcage
-                                                                                                                            *top*
-                                                                                                                            #t)))
-                                                                                                                     (#%cons
-                                                                                                                       '#(syntax-object
-                                                                                                                          $module
-                                                                                                                          ((top)
-                                                                                                                            #(ribcage
-                                                                                                                              #(d
-                                                                                                                                tmid
-                                                                                                                                old-id
-                                                                                                                                tmp
-                                                                                                                                id)
-                                                                                                                              #((top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"
-                                                                                                                                "i"
-                                                                                                                                "i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(mid
-                                                                                                                                d
-                                                                                                                                exports)
-                                                                                                                              #((top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(m
-                                                                                                                                prefix-id)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(orig
-                                                                                                                                import-only?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(m
-                                                                                                                                exports?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              (modspec*
-                                                                                                                                modspec
-                                                                                                                                gen-mid
-                                                                                                                                prefix-drop
-                                                                                                                                prefix-add
-                                                                                                                                difference)
-                                                                                                                              ((top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              ("i" "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(r)
-                                                                                                                              #((top))
-                                                                                                                              #("i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(orig
-                                                                                                                                import-only?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ($import-help
-                                                                                                                                $module-exports)
-                                                                                                                              ((top)
-                                                                                                                                (top))
-                                                                                                                              ("i" "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              (lambda-var-list
-                                                                                                                               gen-var
-                                                                                                                               strip
-                                                                                                                               strip*
-                                                                                                                               strip-annotation
-                                                                                                                               ellipsis?
-                                                                                                                               chi-void
-                                                                                                                               chi-local-syntax
-                                                                                                                               chi-lambda-clause
-                                                                                                                               parse-begin
-                                                                                                                               parse-alias
-                                                                                                                               parse-eval-when
-                                                                                                                               parse-meta
-                                                                                                                               parse-define-syntax
-                                                                                                                               parse-define
-                                                                                                                               parse-import
-                                                                                                                               parse-module
-                                                                                                                               do-import!
-                                                                                                                               lookup-import-label
-                                                                                                                               import-mark-delta
-                                                                                                                               chi-internal
-                                                                                                                               chi-body
-                                                                                                                               chi-macro
-                                                                                                                               chi-set!
-                                                                                                                               chi-application
-                                                                                                                               chi-expr
-                                                                                                                               chi
-                                                                                                                               chi-sequence
-                                                                                                                               chi-meta-frob
-                                                                                                                               chi-frobs
-                                                                                                                               ct-eval/residualize3
-                                                                                                                               ct-eval/residualize2
-                                                                                                                               rt-eval/residualize
-                                                                                                                               initial-mode-set
-                                                                                                                               update-mode-set
-                                                                                                                               do-top-import
-                                                                                                                               vfor-each
-                                                                                                                               vmap
-                                                                                                                               chi-external
-                                                                                                                               check-defined-ids
-                                                                                                                               check-module-exports
-                                                                                                                               id-set-diff
-                                                                                                                               chi-top-module
-                                                                                                                               set-frob-meta?!
-                                                                                                                               set-frob-e!
-                                                                                                                               frob-meta?
-                                                                                                                               frob-e
-                                                                                                                               frob?
-                                                                                                                               make-frob
-                                                                                                                               create-module-binding
-                                                                                                                               set-module-binding-exported!
-                                                                                                                               set-module-binding-val!
-                                                                                                                               set-module-binding-imps!
-                                                                                                                               set-module-binding-label!
-                                                                                                                               set-module-binding-id!
-                                                                                                                               set-module-binding-type!
-                                                                                                                               module-binding-exported
-                                                                                                                               module-binding-val
-                                                                                                                               module-binding-imps
-                                                                                                                               module-binding-label
-                                                                                                                               module-binding-id
-                                                                                                                               module-binding-type
-                                                                                                                               module-binding?
-                                                                                                                               make-module-binding
-                                                                                                                               make-resolved-interface
-                                                                                                                               make-unresolved-interface
-                                                                                                                               set-interface-token!
-                                                                                                                               set-interface-exports!
-                                                                                                                               set-interface-marks!
-                                                                                                                               interface-token
-                                                                                                                               interface-exports
-                                                                                                                               interface-marks
-                                                                                                                               interface?
-                                                                                                                               make-interface
-                                                                                                                               flatten-exports
-                                                                                                                               chi-top
-                                                                                                                               chi-top-sequence
-                                                                                                                               chi-top*
-                                                                                                                               syntax-type
-                                                                                                                               chi-when-list
-                                                                                                                               source-wrap
-                                                                                                                               wrap
-                                                                                                                               bound-id-member?
-                                                                                                                               invalid-ids-error
-                                                                                                                               distinct-bound-ids?
-                                                                                                                               valid-bound-ids?
-                                                                                                                               bound-id=?
-                                                                                                                               help-bound-id=?
-                                                                                                                               literal-id=?
-                                                                                                                               free-id=?
-                                                                                                                               id-var-name
-                                                                                                                               id-var-name-loc
-                                                                                                                               id-var-name&marks
-                                                                                                                               id-var-name-loc&marks
-                                                                                                                               top-id-free-var-name
-                                                                                                                               top-id-bound-var-name
-                                                                                                                               anon
-                                                                                                                               diff-marks
-                                                                                                                               same-marks?
-                                                                                                                               join-subst
-                                                                                                                               join-marks
-                                                                                                                               join-wraps
-                                                                                                                               smart-append
-                                                                                                                               resolved-id-var-name
-                                                                                                                               id->resolved-id
-                                                                                                                               make-resolved-id
-                                                                                                                               make-binding-wrap
-                                                                                                                               store-import-binding
-                                                                                                                               lookup-import-binding-name
-                                                                                                                               extend-ribcage-subst!
-                                                                                                                               extend-ribcage-barrier-help!
-                                                                                                                               extend-ribcage-barrier!
-                                                                                                                               import-extend-ribcage!
-                                                                                                                               extend-ribcage!
-                                                                                                                               make-empty-ribcage
-                                                                                                                               barrier-marker
-                                                                                                                               new-mark
-                                                                                                                               anti-mark
-                                                                                                                               the-anti-mark
-                                                                                                                               set-env-wrap!
-                                                                                                                               set-env-top-ribcage!
-                                                                                                                               env-wrap
-                                                                                                                               env-top-ribcage
-                                                                                                                               env?
-                                                                                                                               make-env
-                                                                                                                               set-import-interface-new-marks!
-                                                                                                                               set-import-interface-interface!
-                                                                                                                               import-interface-new-marks
-                                                                                                                               import-interface-interface
-                                                                                                                               import-interface?
-                                                                                                                               make-import-interface
-                                                                                                                               set-top-ribcage-mutable?!
-                                                                                                                               set-top-ribcage-key!
-                                                                                                                               top-ribcage-mutable?
-                                                                                                                               top-ribcage-key
-                                                                                                                               top-ribcage?
-                                                                                                                               make-top-ribcage
-                                                                                                                               set-ribcage-labels!
-                                                                                                                               set-ribcage-marks!
-                                                                                                                               set-ribcage-symnames!
-                                                                                                                               ribcage-labels
-                                                                                                                               ribcage-marks
-                                                                                                                               ribcage-symnames
-                                                                                                                               ribcage?
-                                                                                                                               make-ribcage
-                                                                                                                               gen-labels
-                                                                                                                               label?
-                                                                                                                               gen-label
-                                                                                                                               set-indirect-label!
-                                                                                                                               get-indirect-label
-                                                                                                                               indirect-label?
-                                                                                                                               gen-indirect-label
-                                                                                                                               anon
-                                                                                                                               only-top-marked?
-                                                                                                                               top-marked?
-                                                                                                                               top-wrap
-                                                                                                                               empty-wrap
-                                                                                                                               wrap-subst
-                                                                                                                               wrap-marks
-                                                                                                                               make-wrap
-                                                                                                                               id-sym-name&marks
-                                                                                                                               id-subst
-                                                                                                                               id-marks
-                                                                                                                               id-sym-name
-                                                                                                                               id?
-                                                                                                                               nonsymbol-id?
-                                                                                                                               global-extend
-                                                                                                                               defer-or-eval-transformer
-                                                                                                                               make-transformer-binding
-                                                                                                                               lookup
-                                                                                                                               lookup*
-                                                                                                                               displaced-lexical-error
-                                                                                                                               displaced-lexical?
-                                                                                                                               extend-var-env*
-                                                                                                                               extend-env*
-                                                                                                                               extend-env
-                                                                                                                               null-env
-                                                                                                                               binding?
-                                                                                                                               set-binding-value!
-                                                                                                                               set-binding-type!
-                                                                                                                               binding-value
-                                                                                                                               binding-type
-                                                                                                                               make-binding
-                                                                                                                               sanitize-binding
-                                                                                                                               arg-check
-                                                                                                                               no-source
-                                                                                                                               unannotate
-                                                                                                                               self-evaluating?
-                                                                                                                               lexical-var?
-                                                                                                                               build-lexical-var
-                                                                                                                               build-top-module
-                                                                                                                               build-body
-                                                                                                                               build-letrec
-                                                                                                                               build-sequence
-                                                                                                                               build-data
-                                                                                                                               build-primref
-                                                                                                                               built-lambda?
-                                                                                                                               build-lambda
-                                                                                                                               build-revisit-only
-                                                                                                                               build-visit-only
-                                                                                                                               build-cte-install
-                                                                                                                               build-global-definition
-                                                                                                                               build-global-assignment
-                                                                                                                               build-global-reference
-                                                                                                                               build-lexical-assignment
-                                                                                                                               build-lexical-reference
-                                                                                                                               build-conditional
-                                                                                                                               build-application
-                                                                                                                               generate-id
-                                                                                                                               put-import-binding
-                                                                                                                               get-import-binding
-                                                                                                                               read-only-binding?
-                                                                                                                               put-global-definition-hook
-                                                                                                                               get-global-definition-hook
-                                                                                                                               put-cte-hook
-                                                                                                                               gensym-hook
-                                                                                                                               error-hook
-                                                                                                                               define-top-level-value-hook
-                                                                                                                               local-eval-hook
-                                                                                                                               top-level-eval-hook
-                                                                                                                               annotation?
-                                                                                                                               set-syntax-object-wrap!
-                                                                                                                               set-syntax-object-expression!
-                                                                                                                               syntax-object-wrap
-                                                                                                                               syntax-object-expression
-                                                                                                                               syntax-object?
-                                                                                                                               make-syntax-object
-                                                                                                                               noexpand
-                                                                                                                               let-values
-                                                                                                                               define-structure
-                                                                                                                               unless
-                                                                                                                               when)
-                                                                                                                              ((top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               ("m" top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               ("m" top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top))
-                                                                                                                              ("i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"))
-                                                                                                                            #(top-ribcage
-                                                                                                                              *top*
-                                                                                                                              #t)))
-                                                                                                                       (#%cons
-                                                                                                                         g847
-                                                                                                                         (#%cons
-                                                                                                                           g886
-                                                                                                                           (#%cons
-                                                                                                                             (#%map
-                                                                                                                               #%list
-                                                                                                                               g889
-                                                                                                                               g888)
-                                                                                                                             (#%cons
-                                                                                                                               (#%cons
-                                                                                                                                 '#(syntax-object
-                                                                                                                                    $module
-                                                                                                                                    ((top)
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(d
-                                                                                                                                          tmid
-                                                                                                                                          old-id
-                                                                                                                                          tmp
-                                                                                                                                          id)
-                                                                                                                                        #((top)
-                                                                                                                                          (top)
-                                                                                                                                          (top)
-                                                                                                                                          (top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"
-                                                                                                                                          "i"
-                                                                                                                                          "i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        ()
-                                                                                                                                        ()
-                                                                                                                                        ())
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(mid
-                                                                                                                                          d
-                                                                                                                                          exports)
-                                                                                                                                        #((top)
-                                                                                                                                          (top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(m
-                                                                                                                                          prefix-id)
-                                                                                                                                        #((top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(orig
-                                                                                                                                          import-only?)
-                                                                                                                                        #((top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        ()
-                                                                                                                                        ()
-                                                                                                                                        ())
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(m
-                                                                                                                                          exports?)
-                                                                                                                                        #((top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        (modspec*
-                                                                                                                                          modspec
-                                                                                                                                          gen-mid
-                                                                                                                                          prefix-drop
-                                                                                                                                          prefix-add
-                                                                                                                                          difference)
-                                                                                                                                        ((top)
-                                                                                                                                          (top)
-                                                                                                                                          (top)
-                                                                                                                                          (top)
-                                                                                                                                          (top)
-                                                                                                                                          (top))
-                                                                                                                                        ("i" "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(r)
-                                                                                                                                        #((top))
-                                                                                                                                        #("i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        ()
-                                                                                                                                        ()
-                                                                                                                                        ())
-                                                                                                                                      #(ribcage
-                                                                                                                                        #(orig
-                                                                                                                                          import-only?)
-                                                                                                                                        #((top)
-                                                                                                                                          (top))
-                                                                                                                                        #("i"
-                                                                                                                                          "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        ($import-help
-                                                                                                                                          $module-exports)
-                                                                                                                                        ((top)
-                                                                                                                                          (top))
-                                                                                                                                        ("i" "i"))
-                                                                                                                                      #(ribcage
-                                                                                                                                        (lambda-var-list
-                                                                                                                                         gen-var
-                                                                                                                                         strip
-                                                                                                                                         strip*
-                                                                                                                                         strip-annotation
-                                                                                                                                         ellipsis?
-                                                                                                                                         chi-void
-                                                                                                                                         chi-local-syntax
-                                                                                                                                         chi-lambda-clause
-                                                                                                                                         parse-begin
-                                                                                                                                         parse-alias
-                                                                                                                                         parse-eval-when
-                                                                                                                                         parse-meta
-                                                                                                                                         parse-define-syntax
-                                                                                                                                         parse-define
-                                                                                                                                         parse-import
-                                                                                                                                         parse-module
-                                                                                                                                         do-import!
-                                                                                                                                         lookup-import-label
-                                                                                                                                         import-mark-delta
-                                                                                                                                         chi-internal
-                                                                                                                                         chi-body
-                                                                                                                                         chi-macro
-                                                                                                                                         chi-set!
-                                                                                                                                         chi-application
-                                                                                                                                         chi-expr
-                                                                                                                                         chi
-                                                                                                                                         chi-sequence
-                                                                                                                                         chi-meta-frob
-                                                                                                                                         chi-frobs
-                                                                                                                                         ct-eval/residualize3
-                                                                                                                                         ct-eval/residualize2
-                                                                                                                                         rt-eval/residualize
-                                                                                                                                         initial-mode-set
-                                                                                                                                         update-mode-set
-                                                                                                                                         do-top-import
-                                                                                                                                         vfor-each
-                                                                                                                                         vmap
-                                                                                                                                         chi-external
-                                                                                                                                         check-defined-ids
-                                                                                                                                         check-module-exports
-                                                                                                                                         id-set-diff
-                                                                                                                                         chi-top-module
-                                                                                                                                         set-frob-meta?!
-                                                                                                                                         set-frob-e!
-                                                                                                                                         frob-meta?
-                                                                                                                                         frob-e
-                                                                                                                                         frob?
-                                                                                                                                         make-frob
-                                                                                                                                         create-module-binding
-                                                                                                                                         set-module-binding-exported!
-                                                                                                                                         set-module-binding-val!
-                                                                                                                                         set-module-binding-imps!
-                                                                                                                                         set-module-binding-label!
-                                                                                                                                         set-module-binding-id!
-                                                                                                                                         set-module-binding-type!
-                                                                                                                                         module-binding-exported
-                                                                                                                                         module-binding-val
-                                                                                                                                         module-binding-imps
-                                                                                                                                         module-binding-label
-                                                                                                                                         module-binding-id
-                                                                                                                                         module-binding-type
-                                                                                                                                         module-binding?
-                                                                                                                                         make-module-binding
-                                                                                                                                         make-resolved-interface
-                                                                                                                                         make-unresolved-interface
-                                                                                                                                         set-interface-token!
-                                                                                                                                         set-interface-exports!
-                                                                                                                                         set-interface-marks!
-                                                                                                                                         interface-token
-                                                                                                                                         interface-exports
-                                                                                                                                         interface-marks
-                                                                                                                                         interface?
-                                                                                                                                         make-interface
-                                                                                                                                         flatten-exports
-                                                                                                                                         chi-top
-                                                                                                                                         chi-top-sequence
-                                                                                                                                         chi-top*
-                                                                                                                                         syntax-type
-                                                                                                                                         chi-when-list
-                                                                                                                                         source-wrap
-                                                                                                                                         wrap
-                                                                                                                                         bound-id-member?
-                                                                                                                                         invalid-ids-error
-                                                                                                                                         distinct-bound-ids?
-                                                                                                                                         valid-bound-ids?
-                                                                                                                                         bound-id=?
-                                                                                                                                         help-bound-id=?
-                                                                                                                                         literal-id=?
-                                                                                                                                         free-id=?
-                                                                                                                                         id-var-name
-                                                                                                                                         id-var-name-loc
-                                                                                                                                         id-var-name&marks
-                                                                                                                                         id-var-name-loc&marks
-                                                                                                                                         top-id-free-var-name
-                                                                                                                                         top-id-bound-var-name
-                                                                                                                                         anon
-                                                                                                                                         diff-marks
-                                                                                                                                         same-marks?
-                                                                                                                                         join-subst
-                                                                                                                                         join-marks
-                                                                                                                                         join-wraps
-                                                                                                                                         smart-append
-                                                                                                                                         resolved-id-var-name
-                                                                                                                                         id->resolved-id
-                                                                                                                                         make-resolved-id
-                                                                                                                                         make-binding-wrap
-                                                                                                                                         store-import-binding
-                                                                                                                                         lookup-import-binding-name
-                                                                                                                                         extend-ribcage-subst!
-                                                                                                                                         extend-ribcage-barrier-help!
-                                                                                                                                         extend-ribcage-barrier!
-                                                                                                                                         import-extend-ribcage!
-                                                                                                                                         extend-ribcage!
-                                                                                                                                         make-empty-ribcage
-                                                                                                                                         barrier-marker
-                                                                                                                                         new-mark
-                                                                                                                                         anti-mark
-                                                                                                                                         the-anti-mark
-                                                                                                                                         set-env-wrap!
-                                                                                                                                         set-env-top-ribcage!
-                                                                                                                                         env-wrap
-                                                                                                                                         env-top-ribcage
-                                                                                                                                         env?
-                                                                                                                                         make-env
-                                                                                                                                         set-import-interface-new-marks!
-                                                                                                                                         set-import-interface-interface!
-                                                                                                                                         import-interface-new-marks
-                                                                                                                                         import-interface-interface
-                                                                                                                                         import-interface?
-                                                                                                                                         make-import-interface
-                                                                                                                                         set-top-ribcage-mutable?!
-                                                                                                                                         set-top-ribcage-key!
-                                                                                                                                         top-ribcage-mutable?
-                                                                                                                                         top-ribcage-key
-                                                                                                                                         top-ribcage?
-                                                                                                                                         make-top-ribcage
-                                                                                                                                         set-ribcage-labels!
-                                                                                                                                         set-ribcage-marks!
-                                                                                                                                         set-ribcage-symnames!
-                                                                                                                                         ribcage-labels
-                                                                                                                                         ribcage-marks
-                                                                                                                                         ribcage-symnames
-                                                                                                                                         ribcage?
-                                                                                                                                         make-ribcage
-                                                                                                                                         gen-labels
-                                                                                                                                         label?
-                                                                                                                                         gen-label
-                                                                                                                                         set-indirect-label!
-                                                                                                                                         get-indirect-label
-                                                                                                                                         indirect-label?
-                                                                                                                                         gen-indirect-label
-                                                                                                                                         anon
-                                                                                                                                         only-top-marked?
-                                                                                                                                         top-marked?
-                                                                                                                                         top-wrap
-                                                                                                                                         empty-wrap
-                                                                                                                                         wrap-subst
-                                                                                                                                         wrap-marks
-                                                                                                                                         make-wrap
-                                                                                                                                         id-sym-name&marks
-                                                                                                                                         id-subst
-                                                                                                                                         id-marks
-                                                                                                                                         id-sym-name
-                                                                                                                                         id?
-                                                                                                                                         nonsymbol-id?
-                                                                                                                                         global-extend
-                                                                                                                                         defer-or-eval-transformer
-                                                                                                                                         make-transformer-binding
-                                                                                                                                         lookup
-                                                                                                                                         lookup*
-                                                                                                                                         displaced-lexical-error
-                                                                                                                                         displaced-lexical?
-                                                                                                                                         extend-var-env*
-                                                                                                                                         extend-env*
-                                                                                                                                         extend-env
-                                                                                                                                         null-env
-                                                                                                                                         binding?
-                                                                                                                                         set-binding-value!
-                                                                                                                                         set-binding-type!
-                                                                                                                                         binding-value
-                                                                                                                                         binding-type
-                                                                                                                                         make-binding
-                                                                                                                                         sanitize-binding
-                                                                                                                                         arg-check
-                                                                                                                                         no-source
-                                                                                                                                         unannotate
-                                                                                                                                         self-evaluating?
-                                                                                                                                         lexical-var?
-                                                                                                                                         build-lexical-var
-                                                                                                                                         build-top-module
-                                                                                                                                         build-body
-                                                                                                                                         build-letrec
-                                                                                                                                         build-sequence
-                                                                                                                                         build-data
-                                                                                                                                         build-primref
-                                                                                                                                         built-lambda?
-                                                                                                                                         build-lambda
-                                                                                                                                         build-revisit-only
-                                                                                                                                         build-visit-only
-                                                                                                                                         build-cte-install
-                                                                                                                                         build-global-definition
-                                                                                                                                         build-global-assignment
-                                                                                                                                         build-global-reference
-                                                                                                                                         build-lexical-assignment
-                                                                                                                                         build-lexical-reference
-                                                                                                                                         build-conditional
-                                                                                                                                         build-application
-                                                                                                                                         generate-id
-                                                                                                                                         put-import-binding
-                                                                                                                                         get-import-binding
-                                                                                                                                         read-only-binding?
-                                                                                                                                         put-global-definition-hook
-                                                                                                                                         get-global-definition-hook
-                                                                                                                                         put-cte-hook
-                                                                                                                                         gensym-hook
-                                                                                                                                         error-hook
-                                                                                                                                         define-top-level-value-hook
-                                                                                                                                         local-eval-hook
-                                                                                                                                         top-level-eval-hook
-                                                                                                                                         annotation?
-                                                                                                                                         set-syntax-object-wrap!
-                                                                                                                                         set-syntax-object-expression!
-                                                                                                                                         syntax-object-wrap
-                                                                                                                                         syntax-object-expression
-                                                                                                                                         syntax-object?
-                                                                                                                                         make-syntax-object
-                                                                                                                                         noexpand
-                                                                                                                                         let-values
-                                                                                                                                         define-structure
-                                                                                                                                         unless
-                                                                                                                                         when)
-                                                                                                                                        ((top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         ("m" top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         ("m" top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top)
-                                                                                                                                         (top))
-                                                                                                                                        ("i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"))
-                                                                                                                                      #(top-ribcage
-                                                                                                                                        *top*
-                                                                                                                                        #t)))
-                                                                                                                                 (#%cons
-                                                                                                                                   g847
-                                                                                                                                   (#%cons
-                                                                                                                                     g886
-                                                                                                                                     (#%cons
-                                                                                                                                       (#%map
-                                                                                                                                         #%list
-                                                                                                                                         g888
-                                                                                                                                         g887)
-                                                                                                                                       (#%cons
-                                                                                                                                         g885
-                                                                                                                                         (#%map
-                                                                                                                                           (case-lambda
-                                                                                                                                             [(g890
-                                                                                                                                               g891)
-                                                                                                                                              (#%list
-                                                                                                                                                '#(syntax-object
-                                                                                                                                                   alias
-                                                                                                                                                   ((top)
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(d
-                                                                                                                                                         tmid
-                                                                                                                                                         old-id
-                                                                                                                                                         tmp
-                                                                                                                                                         id)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(mid
-                                                                                                                                                         d
-                                                                                                                                                         exports)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(m
-                                                                                                                                                         prefix-id)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(orig
-                                                                                                                                                         import-only?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(m
-                                                                                                                                                         exports?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       (modspec*
-                                                                                                                                                         modspec
-                                                                                                                                                         gen-mid
-                                                                                                                                                         prefix-drop
-                                                                                                                                                         prefix-add
-                                                                                                                                                         difference)
-                                                                                                                                                       ((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       ("i" "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(r)
-                                                                                                                                                       #((top))
-                                                                                                                                                       #("i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(orig
-                                                                                                                                                         import-only?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ($import-help
-                                                                                                                                                         $module-exports)
-                                                                                                                                                       ((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       ("i" "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       (lambda-var-list
-                                                                                                                                                        gen-var
-                                                                                                                                                        strip
-                                                                                                                                                        strip*
-                                                                                                                                                        strip-annotation
-                                                                                                                                                        ellipsis?
-                                                                                                                                                        chi-void
-                                                                                                                                                        chi-local-syntax
-                                                                                                                                                        chi-lambda-clause
-                                                                                                                                                        parse-begin
-                                                                                                                                                        parse-alias
-                                                                                                                                                        parse-eval-when
-                                                                                                                                                        parse-meta
-                                                                                                                                                        parse-define-syntax
-                                                                                                                                                        parse-define
-                                                                                                                                                        parse-import
-                                                                                                                                                        parse-module
-                                                                                                                                                        do-import!
-                                                                                                                                                        lookup-import-label
-                                                                                                                                                        import-mark-delta
-                                                                                                                                                        chi-internal
-                                                                                                                                                        chi-body
-                                                                                                                                                        chi-macro
-                                                                                                                                                        chi-set!
-                                                                                                                                                        chi-application
-                                                                                                                                                        chi-expr
-                                                                                                                                                        chi
-                                                                                                                                                        chi-sequence
-                                                                                                                                                        chi-meta-frob
-                                                                                                                                                        chi-frobs
-                                                                                                                                                        ct-eval/residualize3
-                                                                                                                                                        ct-eval/residualize2
-                                                                                                                                                        rt-eval/residualize
-                                                                                                                                                        initial-mode-set
-                                                                                                                                                        update-mode-set
-                                                                                                                                                        do-top-import
-                                                                                                                                                        vfor-each
-                                                                                                                                                        vmap
-                                                                                                                                                        chi-external
-                                                                                                                                                        check-defined-ids
-                                                                                                                                                        check-module-exports
-                                                                                                                                                        id-set-diff
-                                                                                                                                                        chi-top-module
-                                                                                                                                                        set-frob-meta?!
-                                                                                                                                                        set-frob-e!
-                                                                                                                                                        frob-meta?
-                                                                                                                                                        frob-e
-                                                                                                                                                        frob?
-                                                                                                                                                        make-frob
-                                                                                                                                                        create-module-binding
-                                                                                                                                                        set-module-binding-exported!
-                                                                                                                                                        set-module-binding-val!
-                                                                                                                                                        set-module-binding-imps!
-                                                                                                                                                        set-module-binding-label!
-                                                                                                                                                        set-module-binding-id!
-                                                                                                                                                        set-module-binding-type!
-                                                                                                                                                        module-binding-exported
-                                                                                                                                                        module-binding-val
-                                                                                                                                                        module-binding-imps
-                                                                                                                                                        module-binding-label
-                                                                                                                                                        module-binding-id
-                                                                                                                                                        module-binding-type
-                                                                                                                                                        module-binding?
-                                                                                                                                                        make-module-binding
-                                                                                                                                                        make-resolved-interface
-                                                                                                                                                        make-unresolved-interface
-                                                                                                                                                        set-interface-token!
-                                                                                                                                                        set-interface-exports!
-                                                                                                                                                        set-interface-marks!
-                                                                                                                                                        interface-token
-                                                                                                                                                        interface-exports
-                                                                                                                                                        interface-marks
-                                                                                                                                                        interface?
-                                                                                                                                                        make-interface
-                                                                                                                                                        flatten-exports
-                                                                                                                                                        chi-top
-                                                                                                                                                        chi-top-sequence
-                                                                                                                                                        chi-top*
-                                                                                                                                                        syntax-type
-                                                                                                                                                        chi-when-list
-                                                                                                                                                        source-wrap
-                                                                                                                                                        wrap
-                                                                                                                                                        bound-id-member?
-                                                                                                                                                        invalid-ids-error
-                                                                                                                                                        distinct-bound-ids?
-                                                                                                                                                        valid-bound-ids?
-                                                                                                                                                        bound-id=?
-                                                                                                                                                        help-bound-id=?
-                                                                                                                                                        literal-id=?
-                                                                                                                                                        free-id=?
-                                                                                                                                                        id-var-name
-                                                                                                                                                        id-var-name-loc
-                                                                                                                                                        id-var-name&marks
-                                                                                                                                                        id-var-name-loc&marks
-                                                                                                                                                        top-id-free-var-name
-                                                                                                                                                        top-id-bound-var-name
-                                                                                                                                                        anon
-                                                                                                                                                        diff-marks
-                                                                                                                                                        same-marks?
-                                                                                                                                                        join-subst
-                                                                                                                                                        join-marks
-                                                                                                                                                        join-wraps
-                                                                                                                                                        smart-append
-                                                                                                                                                        resolved-id-var-name
-                                                                                                                                                        id->resolved-id
-                                                                                                                                                        make-resolved-id
-                                                                                                                                                        make-binding-wrap
-                                                                                                                                                        store-import-binding
-                                                                                                                                                        lookup-import-binding-name
-                                                                                                                                                        extend-ribcage-subst!
-                                                                                                                                                        extend-ribcage-barrier-help!
-                                                                                                                                                        extend-ribcage-barrier!
-                                                                                                                                                        import-extend-ribcage!
-                                                                                                                                                        extend-ribcage!
-                                                                                                                                                        make-empty-ribcage
-                                                                                                                                                        barrier-marker
-                                                                                                                                                        new-mark
-                                                                                                                                                        anti-mark
-                                                                                                                                                        the-anti-mark
-                                                                                                                                                        set-env-wrap!
-                                                                                                                                                        set-env-top-ribcage!
-                                                                                                                                                        env-wrap
-                                                                                                                                                        env-top-ribcage
-                                                                                                                                                        env?
-                                                                                                                                                        make-env
-                                                                                                                                                        set-import-interface-new-marks!
-                                                                                                                                                        set-import-interface-interface!
-                                                                                                                                                        import-interface-new-marks
-                                                                                                                                                        import-interface-interface
-                                                                                                                                                        import-interface?
-                                                                                                                                                        make-import-interface
-                                                                                                                                                        set-top-ribcage-mutable?!
-                                                                                                                                                        set-top-ribcage-key!
-                                                                                                                                                        top-ribcage-mutable?
-                                                                                                                                                        top-ribcage-key
-                                                                                                                                                        top-ribcage?
-                                                                                                                                                        make-top-ribcage
-                                                                                                                                                        set-ribcage-labels!
-                                                                                                                                                        set-ribcage-marks!
-                                                                                                                                                        set-ribcage-symnames!
-                                                                                                                                                        ribcage-labels
-                                                                                                                                                        ribcage-marks
-                                                                                                                                                        ribcage-symnames
-                                                                                                                                                        ribcage?
-                                                                                                                                                        make-ribcage
-                                                                                                                                                        gen-labels
-                                                                                                                                                        label?
-                                                                                                                                                        gen-label
-                                                                                                                                                        set-indirect-label!
-                                                                                                                                                        get-indirect-label
-                                                                                                                                                        indirect-label?
-                                                                                                                                                        gen-indirect-label
-                                                                                                                                                        anon
-                                                                                                                                                        only-top-marked?
-                                                                                                                                                        top-marked?
-                                                                                                                                                        top-wrap
-                                                                                                                                                        empty-wrap
-                                                                                                                                                        wrap-subst
-                                                                                                                                                        wrap-marks
-                                                                                                                                                        make-wrap
-                                                                                                                                                        id-sym-name&marks
-                                                                                                                                                        id-subst
-                                                                                                                                                        id-marks
-                                                                                                                                                        id-sym-name
-                                                                                                                                                        id?
-                                                                                                                                                        nonsymbol-id?
-                                                                                                                                                        global-extend
-                                                                                                                                                        defer-or-eval-transformer
-                                                                                                                                                        make-transformer-binding
-                                                                                                                                                        lookup
-                                                                                                                                                        lookup*
-                                                                                                                                                        displaced-lexical-error
-                                                                                                                                                        displaced-lexical?
-                                                                                                                                                        extend-var-env*
-                                                                                                                                                        extend-env*
-                                                                                                                                                        extend-env
-                                                                                                                                                        null-env
-                                                                                                                                                        binding?
-                                                                                                                                                        set-binding-value!
-                                                                                                                                                        set-binding-type!
-                                                                                                                                                        binding-value
-                                                                                                                                                        binding-type
-                                                                                                                                                        make-binding
-                                                                                                                                                        sanitize-binding
-                                                                                                                                                        arg-check
-                                                                                                                                                        no-source
-                                                                                                                                                        unannotate
-                                                                                                                                                        self-evaluating?
-                                                                                                                                                        lexical-var?
-                                                                                                                                                        build-lexical-var
-                                                                                                                                                        build-top-module
-                                                                                                                                                        build-body
-                                                                                                                                                        build-letrec
-                                                                                                                                                        build-sequence
-                                                                                                                                                        build-data
-                                                                                                                                                        build-primref
-                                                                                                                                                        built-lambda?
-                                                                                                                                                        build-lambda
-                                                                                                                                                        build-revisit-only
-                                                                                                                                                        build-visit-only
-                                                                                                                                                        build-cte-install
-                                                                                                                                                        build-global-definition
-                                                                                                                                                        build-global-assignment
-                                                                                                                                                        build-global-reference
-                                                                                                                                                        build-lexical-assignment
-                                                                                                                                                        build-lexical-reference
-                                                                                                                                                        build-conditional
-                                                                                                                                                        build-application
-                                                                                                                                                        generate-id
-                                                                                                                                                        put-import-binding
-                                                                                                                                                        get-import-binding
-                                                                                                                                                        read-only-binding?
-                                                                                                                                                        put-global-definition-hook
-                                                                                                                                                        get-global-definition-hook
-                                                                                                                                                        put-cte-hook
-                                                                                                                                                        gensym-hook
-                                                                                                                                                        error-hook
-                                                                                                                                                        define-top-level-value-hook
-                                                                                                                                                        local-eval-hook
-                                                                                                                                                        top-level-eval-hook
-                                                                                                                                                        annotation?
-                                                                                                                                                        set-syntax-object-wrap!
-                                                                                                                                                        set-syntax-object-expression!
-                                                                                                                                                        syntax-object-wrap
-                                                                                                                                                        syntax-object-expression
-                                                                                                                                                        syntax-object?
-                                                                                                                                                        make-syntax-object
-                                                                                                                                                        noexpand
-                                                                                                                                                        let-values
-                                                                                                                                                        define-structure
-                                                                                                                                                        unless
-                                                                                                                                                        when)
-                                                                                                                                                       ((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        ("m" top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        ("m" top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                       ("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                     #(top-ribcage
-                                                                                                                                                       *top*
-                                                                                                                                                       #t)))
-                                                                                                                                                g891
-                                                                                                                                                g890)])
-                                                                                                                                           g887
-                                                                                                                                           g888))))))
-                                                                                                                               (#%cons
-                                                                                                                                 (#%list
-                                                                                                                                   '#(syntax-object
-                                                                                                                                      $import
-                                                                                                                                      ((top)
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(d
-                                                                                                                                            tmid
-                                                                                                                                            old-id
-                                                                                                                                            tmp
-                                                                                                                                            id)
-                                                                                                                                          #((top)
-                                                                                                                                            (top)
-                                                                                                                                            (top)
-                                                                                                                                            (top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"
-                                                                                                                                            "i"
-                                                                                                                                            "i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          ()
-                                                                                                                                          ()
-                                                                                                                                          ())
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(mid
-                                                                                                                                            d
-                                                                                                                                            exports)
-                                                                                                                                          #((top)
-                                                                                                                                            (top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(m
-                                                                                                                                            prefix-id)
-                                                                                                                                          #((top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(orig
-                                                                                                                                            import-only?)
-                                                                                                                                          #((top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          ()
-                                                                                                                                          ()
-                                                                                                                                          ())
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(m
-                                                                                                                                            exports?)
-                                                                                                                                          #((top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          (modspec*
-                                                                                                                                            modspec
-                                                                                                                                            gen-mid
-                                                                                                                                            prefix-drop
-                                                                                                                                            prefix-add
-                                                                                                                                            difference)
-                                                                                                                                          ((top)
-                                                                                                                                            (top)
-                                                                                                                                            (top)
-                                                                                                                                            (top)
-                                                                                                                                            (top)
-                                                                                                                                            (top))
-                                                                                                                                          ("i" "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(r)
-                                                                                                                                          #((top))
-                                                                                                                                          #("i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          ()
-                                                                                                                                          ()
-                                                                                                                                          ())
-                                                                                                                                        #(ribcage
-                                                                                                                                          #(orig
-                                                                                                                                            import-only?)
-                                                                                                                                          #((top)
-                                                                                                                                            (top))
-                                                                                                                                          #("i"
-                                                                                                                                            "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          ($import-help
-                                                                                                                                            $module-exports)
-                                                                                                                                          ((top)
-                                                                                                                                            (top))
-                                                                                                                                          ("i" "i"))
-                                                                                                                                        #(ribcage
-                                                                                                                                          (lambda-var-list
-                                                                                                                                           gen-var
-                                                                                                                                           strip
-                                                                                                                                           strip*
-                                                                                                                                           strip-annotation
-                                                                                                                                           ellipsis?
-                                                                                                                                           chi-void
-                                                                                                                                           chi-local-syntax
-                                                                                                                                           chi-lambda-clause
-                                                                                                                                           parse-begin
-                                                                                                                                           parse-alias
-                                                                                                                                           parse-eval-when
-                                                                                                                                           parse-meta
-                                                                                                                                           parse-define-syntax
-                                                                                                                                           parse-define
-                                                                                                                                           parse-import
-                                                                                                                                           parse-module
-                                                                                                                                           do-import!
-                                                                                                                                           lookup-import-label
-                                                                                                                                           import-mark-delta
-                                                                                                                                           chi-internal
-                                                                                                                                           chi-body
-                                                                                                                                           chi-macro
-                                                                                                                                           chi-set!
-                                                                                                                                           chi-application
-                                                                                                                                           chi-expr
-                                                                                                                                           chi
-                                                                                                                                           chi-sequence
-                                                                                                                                           chi-meta-frob
-                                                                                                                                           chi-frobs
-                                                                                                                                           ct-eval/residualize3
-                                                                                                                                           ct-eval/residualize2
-                                                                                                                                           rt-eval/residualize
-                                                                                                                                           initial-mode-set
-                                                                                                                                           update-mode-set
-                                                                                                                                           do-top-import
-                                                                                                                                           vfor-each
-                                                                                                                                           vmap
-                                                                                                                                           chi-external
-                                                                                                                                           check-defined-ids
-                                                                                                                                           check-module-exports
-                                                                                                                                           id-set-diff
-                                                                                                                                           chi-top-module
-                                                                                                                                           set-frob-meta?!
-                                                                                                                                           set-frob-e!
-                                                                                                                                           frob-meta?
-                                                                                                                                           frob-e
-                                                                                                                                           frob?
-                                                                                                                                           make-frob
-                                                                                                                                           create-module-binding
-                                                                                                                                           set-module-binding-exported!
-                                                                                                                                           set-module-binding-val!
-                                                                                                                                           set-module-binding-imps!
-                                                                                                                                           set-module-binding-label!
-                                                                                                                                           set-module-binding-id!
-                                                                                                                                           set-module-binding-type!
-                                                                                                                                           module-binding-exported
-                                                                                                                                           module-binding-val
-                                                                                                                                           module-binding-imps
-                                                                                                                                           module-binding-label
-                                                                                                                                           module-binding-id
-                                                                                                                                           module-binding-type
-                                                                                                                                           module-binding?
-                                                                                                                                           make-module-binding
-                                                                                                                                           make-resolved-interface
-                                                                                                                                           make-unresolved-interface
-                                                                                                                                           set-interface-token!
-                                                                                                                                           set-interface-exports!
-                                                                                                                                           set-interface-marks!
-                                                                                                                                           interface-token
-                                                                                                                                           interface-exports
-                                                                                                                                           interface-marks
-                                                                                                                                           interface?
-                                                                                                                                           make-interface
-                                                                                                                                           flatten-exports
-                                                                                                                                           chi-top
-                                                                                                                                           chi-top-sequence
-                                                                                                                                           chi-top*
-                                                                                                                                           syntax-type
-                                                                                                                                           chi-when-list
-                                                                                                                                           source-wrap
-                                                                                                                                           wrap
-                                                                                                                                           bound-id-member?
-                                                                                                                                           invalid-ids-error
-                                                                                                                                           distinct-bound-ids?
-                                                                                                                                           valid-bound-ids?
-                                                                                                                                           bound-id=?
-                                                                                                                                           help-bound-id=?
-                                                                                                                                           literal-id=?
-                                                                                                                                           free-id=?
-                                                                                                                                           id-var-name
-                                                                                                                                           id-var-name-loc
-                                                                                                                                           id-var-name&marks
-                                                                                                                                           id-var-name-loc&marks
-                                                                                                                                           top-id-free-var-name
-                                                                                                                                           top-id-bound-var-name
-                                                                                                                                           anon
-                                                                                                                                           diff-marks
-                                                                                                                                           same-marks?
-                                                                                                                                           join-subst
-                                                                                                                                           join-marks
-                                                                                                                                           join-wraps
-                                                                                                                                           smart-append
-                                                                                                                                           resolved-id-var-name
-                                                                                                                                           id->resolved-id
-                                                                                                                                           make-resolved-id
-                                                                                                                                           make-binding-wrap
-                                                                                                                                           store-import-binding
-                                                                                                                                           lookup-import-binding-name
-                                                                                                                                           extend-ribcage-subst!
-                                                                                                                                           extend-ribcage-barrier-help!
-                                                                                                                                           extend-ribcage-barrier!
-                                                                                                                                           import-extend-ribcage!
-                                                                                                                                           extend-ribcage!
-                                                                                                                                           make-empty-ribcage
-                                                                                                                                           barrier-marker
-                                                                                                                                           new-mark
-                                                                                                                                           anti-mark
-                                                                                                                                           the-anti-mark
-                                                                                                                                           set-env-wrap!
-                                                                                                                                           set-env-top-ribcage!
-                                                                                                                                           env-wrap
-                                                                                                                                           env-top-ribcage
-                                                                                                                                           env?
-                                                                                                                                           make-env
-                                                                                                                                           set-import-interface-new-marks!
-                                                                                                                                           set-import-interface-interface!
-                                                                                                                                           import-interface-new-marks
-                                                                                                                                           import-interface-interface
-                                                                                                                                           import-interface?
-                                                                                                                                           make-import-interface
-                                                                                                                                           set-top-ribcage-mutable?!
-                                                                                                                                           set-top-ribcage-key!
-                                                                                                                                           top-ribcage-mutable?
-                                                                                                                                           top-ribcage-key
-                                                                                                                                           top-ribcage?
-                                                                                                                                           make-top-ribcage
-                                                                                                                                           set-ribcage-labels!
-                                                                                                                                           set-ribcage-marks!
-                                                                                                                                           set-ribcage-symnames!
-                                                                                                                                           ribcage-labels
-                                                                                                                                           ribcage-marks
-                                                                                                                                           ribcage-symnames
-                                                                                                                                           ribcage?
-                                                                                                                                           make-ribcage
-                                                                                                                                           gen-labels
-                                                                                                                                           label?
-                                                                                                                                           gen-label
-                                                                                                                                           set-indirect-label!
-                                                                                                                                           get-indirect-label
-                                                                                                                                           indirect-label?
-                                                                                                                                           gen-indirect-label
-                                                                                                                                           anon
-                                                                                                                                           only-top-marked?
-                                                                                                                                           top-marked?
-                                                                                                                                           top-wrap
-                                                                                                                                           empty-wrap
-                                                                                                                                           wrap-subst
-                                                                                                                                           wrap-marks
-                                                                                                                                           make-wrap
-                                                                                                                                           id-sym-name&marks
-                                                                                                                                           id-subst
-                                                                                                                                           id-marks
-                                                                                                                                           id-sym-name
-                                                                                                                                           id?
-                                                                                                                                           nonsymbol-id?
-                                                                                                                                           global-extend
-                                                                                                                                           defer-or-eval-transformer
-                                                                                                                                           make-transformer-binding
-                                                                                                                                           lookup
-                                                                                                                                           lookup*
-                                                                                                                                           displaced-lexical-error
-                                                                                                                                           displaced-lexical?
-                                                                                                                                           extend-var-env*
-                                                                                                                                           extend-env*
-                                                                                                                                           extend-env
-                                                                                                                                           null-env
-                                                                                                                                           binding?
-                                                                                                                                           set-binding-value!
-                                                                                                                                           set-binding-type!
-                                                                                                                                           binding-value
-                                                                                                                                           binding-type
-                                                                                                                                           make-binding
-                                                                                                                                           sanitize-binding
-                                                                                                                                           arg-check
-                                                                                                                                           no-source
-                                                                                                                                           unannotate
-                                                                                                                                           self-evaluating?
-                                                                                                                                           lexical-var?
-                                                                                                                                           build-lexical-var
-                                                                                                                                           build-top-module
-                                                                                                                                           build-body
-                                                                                                                                           build-letrec
-                                                                                                                                           build-sequence
-                                                                                                                                           build-data
-                                                                                                                                           build-primref
-                                                                                                                                           built-lambda?
-                                                                                                                                           build-lambda
-                                                                                                                                           build-revisit-only
-                                                                                                                                           build-visit-only
-                                                                                                                                           build-cte-install
-                                                                                                                                           build-global-definition
-                                                                                                                                           build-global-assignment
-                                                                                                                                           build-global-reference
-                                                                                                                                           build-lexical-assignment
-                                                                                                                                           build-lexical-reference
-                                                                                                                                           build-conditional
-                                                                                                                                           build-application
-                                                                                                                                           generate-id
-                                                                                                                                           put-import-binding
-                                                                                                                                           get-import-binding
-                                                                                                                                           read-only-binding?
-                                                                                                                                           put-global-definition-hook
-                                                                                                                                           get-global-definition-hook
-                                                                                                                                           put-cte-hook
-                                                                                                                                           gensym-hook
-                                                                                                                                           error-hook
-                                                                                                                                           define-top-level-value-hook
-                                                                                                                                           local-eval-hook
-                                                                                                                                           top-level-eval-hook
-                                                                                                                                           annotation?
-                                                                                                                                           set-syntax-object-wrap!
-                                                                                                                                           set-syntax-object-expression!
-                                                                                                                                           syntax-object-wrap
-                                                                                                                                           syntax-object-expression
-                                                                                                                                           syntax-object?
-                                                                                                                                           make-syntax-object
-                                                                                                                                           noexpand
-                                                                                                                                           let-values
-                                                                                                                                           define-structure
-                                                                                                                                           unless
-                                                                                                                                           when)
-                                                                                                                                          ((top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           ("m" top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           ("m" top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top)
-                                                                                                                                           (top))
-                                                                                                                                          ("i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"))
-                                                                                                                                        #(top-ribcage
-                                                                                                                                          *top*
-                                                                                                                                          #t)))
-                                                                                                                                   g847
-                                                                                                                                   g848
-                                                                                                                                   g886)
-                                                                                                                                 (#%map
-                                                                                                                                   (case-lambda
-                                                                                                                                     [(g892
-                                                                                                                                       g893)
-                                                                                                                                      (#%list
-                                                                                                                                        '#(syntax-object
-                                                                                                                                           alias
-                                                                                                                                           ((top)
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(d
-                                                                                                                                                 tmid
-                                                                                                                                                 old-id
-                                                                                                                                                 tmp
-                                                                                                                                                 id)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               ()
-                                                                                                                                               ()
-                                                                                                                                               ())
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(mid
-                                                                                                                                                 d
-                                                                                                                                                 exports)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(m
-                                                                                                                                                 prefix-id)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(orig
-                                                                                                                                                 import-only?)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               ()
-                                                                                                                                               ()
-                                                                                                                                               ())
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(m
-                                                                                                                                                 exports?)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               (modspec*
-                                                                                                                                                 modspec
-                                                                                                                                                 gen-mid
-                                                                                                                                                 prefix-drop
-                                                                                                                                                 prefix-add
-                                                                                                                                                 difference)
-                                                                                                                                               ((top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top))
-                                                                                                                                               ("i" "i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(r)
-                                                                                                                                               #((top))
-                                                                                                                                               #("i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               ()
-                                                                                                                                               ()
-                                                                                                                                               ())
-                                                                                                                                             #(ribcage
-                                                                                                                                               #(orig
-                                                                                                                                                 import-only?)
-                                                                                                                                               #((top)
-                                                                                                                                                 (top))
-                                                                                                                                               #("i"
-                                                                                                                                                 "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               ($import-help
-                                                                                                                                                 $module-exports)
-                                                                                                                                               ((top)
-                                                                                                                                                 (top))
-                                                                                                                                               ("i" "i"))
-                                                                                                                                             #(ribcage
-                                                                                                                                               (lambda-var-list
-                                                                                                                                                gen-var
-                                                                                                                                                strip
-                                                                                                                                                strip*
-                                                                                                                                                strip-annotation
-                                                                                                                                                ellipsis?
-                                                                                                                                                chi-void
-                                                                                                                                                chi-local-syntax
-                                                                                                                                                chi-lambda-clause
-                                                                                                                                                parse-begin
-                                                                                                                                                parse-alias
-                                                                                                                                                parse-eval-when
-                                                                                                                                                parse-meta
-                                                                                                                                                parse-define-syntax
-                                                                                                                                                parse-define
-                                                                                                                                                parse-import
-                                                                                                                                                parse-module
-                                                                                                                                                do-import!
-                                                                                                                                                lookup-import-label
-                                                                                                                                                import-mark-delta
-                                                                                                                                                chi-internal
-                                                                                                                                                chi-body
-                                                                                                                                                chi-macro
-                                                                                                                                                chi-set!
-                                                                                                                                                chi-application
-                                                                                                                                                chi-expr
-                                                                                                                                                chi
-                                                                                                                                                chi-sequence
-                                                                                                                                                chi-meta-frob
-                                                                                                                                                chi-frobs
-                                                                                                                                                ct-eval/residualize3
-                                                                                                                                                ct-eval/residualize2
-                                                                                                                                                rt-eval/residualize
-                                                                                                                                                initial-mode-set
-                                                                                                                                                update-mode-set
-                                                                                                                                                do-top-import
-                                                                                                                                                vfor-each
-                                                                                                                                                vmap
-                                                                                                                                                chi-external
-                                                                                                                                                check-defined-ids
-                                                                                                                                                check-module-exports
-                                                                                                                                                id-set-diff
-                                                                                                                                                chi-top-module
-                                                                                                                                                set-frob-meta?!
-                                                                                                                                                set-frob-e!
-                                                                                                                                                frob-meta?
-                                                                                                                                                frob-e
-                                                                                                                                                frob?
-                                                                                                                                                make-frob
-                                                                                                                                                create-module-binding
-                                                                                                                                                set-module-binding-exported!
-                                                                                                                                                set-module-binding-val!
-                                                                                                                                                set-module-binding-imps!
-                                                                                                                                                set-module-binding-label!
-                                                                                                                                                set-module-binding-id!
-                                                                                                                                                set-module-binding-type!
-                                                                                                                                                module-binding-exported
-                                                                                                                                                module-binding-val
-                                                                                                                                                module-binding-imps
-                                                                                                                                                module-binding-label
-                                                                                                                                                module-binding-id
-                                                                                                                                                module-binding-type
-                                                                                                                                                module-binding?
-                                                                                                                                                make-module-binding
-                                                                                                                                                make-resolved-interface
-                                                                                                                                                make-unresolved-interface
-                                                                                                                                                set-interface-token!
-                                                                                                                                                set-interface-exports!
-                                                                                                                                                set-interface-marks!
-                                                                                                                                                interface-token
-                                                                                                                                                interface-exports
-                                                                                                                                                interface-marks
-                                                                                                                                                interface?
-                                                                                                                                                make-interface
-                                                                                                                                                flatten-exports
-                                                                                                                                                chi-top
-                                                                                                                                                chi-top-sequence
-                                                                                                                                                chi-top*
-                                                                                                                                                syntax-type
-                                                                                                                                                chi-when-list
-                                                                                                                                                source-wrap
-                                                                                                                                                wrap
-                                                                                                                                                bound-id-member?
-                                                                                                                                                invalid-ids-error
-                                                                                                                                                distinct-bound-ids?
-                                                                                                                                                valid-bound-ids?
-                                                                                                                                                bound-id=?
-                                                                                                                                                help-bound-id=?
-                                                                                                                                                literal-id=?
-                                                                                                                                                free-id=?
-                                                                                                                                                id-var-name
-                                                                                                                                                id-var-name-loc
-                                                                                                                                                id-var-name&marks
-                                                                                                                                                id-var-name-loc&marks
-                                                                                                                                                top-id-free-var-name
-                                                                                                                                                top-id-bound-var-name
-                                                                                                                                                anon
-                                                                                                                                                diff-marks
-                                                                                                                                                same-marks?
-                                                                                                                                                join-subst
-                                                                                                                                                join-marks
-                                                                                                                                                join-wraps
-                                                                                                                                                smart-append
-                                                                                                                                                resolved-id-var-name
-                                                                                                                                                id->resolved-id
-                                                                                                                                                make-resolved-id
-                                                                                                                                                make-binding-wrap
-                                                                                                                                                store-import-binding
-                                                                                                                                                lookup-import-binding-name
-                                                                                                                                                extend-ribcage-subst!
-                                                                                                                                                extend-ribcage-barrier-help!
-                                                                                                                                                extend-ribcage-barrier!
-                                                                                                                                                import-extend-ribcage!
-                                                                                                                                                extend-ribcage!
-                                                                                                                                                make-empty-ribcage
-                                                                                                                                                barrier-marker
-                                                                                                                                                new-mark
-                                                                                                                                                anti-mark
-                                                                                                                                                the-anti-mark
-                                                                                                                                                set-env-wrap!
-                                                                                                                                                set-env-top-ribcage!
-                                                                                                                                                env-wrap
-                                                                                                                                                env-top-ribcage
-                                                                                                                                                env?
-                                                                                                                                                make-env
-                                                                                                                                                set-import-interface-new-marks!
-                                                                                                                                                set-import-interface-interface!
-                                                                                                                                                import-interface-new-marks
-                                                                                                                                                import-interface-interface
-                                                                                                                                                import-interface?
-                                                                                                                                                make-import-interface
-                                                                                                                                                set-top-ribcage-mutable?!
-                                                                                                                                                set-top-ribcage-key!
-                                                                                                                                                top-ribcage-mutable?
-                                                                                                                                                top-ribcage-key
-                                                                                                                                                top-ribcage?
-                                                                                                                                                make-top-ribcage
-                                                                                                                                                set-ribcage-labels!
-                                                                                                                                                set-ribcage-marks!
-                                                                                                                                                set-ribcage-symnames!
-                                                                                                                                                ribcage-labels
-                                                                                                                                                ribcage-marks
-                                                                                                                                                ribcage-symnames
-                                                                                                                                                ribcage?
-                                                                                                                                                make-ribcage
-                                                                                                                                                gen-labels
-                                                                                                                                                label?
-                                                                                                                                                gen-label
-                                                                                                                                                set-indirect-label!
-                                                                                                                                                get-indirect-label
-                                                                                                                                                indirect-label?
-                                                                                                                                                gen-indirect-label
-                                                                                                                                                anon
-                                                                                                                                                only-top-marked?
-                                                                                                                                                top-marked?
-                                                                                                                                                top-wrap
-                                                                                                                                                empty-wrap
-                                                                                                                                                wrap-subst
-                                                                                                                                                wrap-marks
-                                                                                                                                                make-wrap
-                                                                                                                                                id-sym-name&marks
-                                                                                                                                                id-subst
-                                                                                                                                                id-marks
-                                                                                                                                                id-sym-name
-                                                                                                                                                id?
-                                                                                                                                                nonsymbol-id?
-                                                                                                                                                global-extend
-                                                                                                                                                defer-or-eval-transformer
-                                                                                                                                                make-transformer-binding
-                                                                                                                                                lookup
-                                                                                                                                                lookup*
-                                                                                                                                                displaced-lexical-error
-                                                                                                                                                displaced-lexical?
-                                                                                                                                                extend-var-env*
-                                                                                                                                                extend-env*
-                                                                                                                                                extend-env
-                                                                                                                                                null-env
-                                                                                                                                                binding?
-                                                                                                                                                set-binding-value!
-                                                                                                                                                set-binding-type!
-                                                                                                                                                binding-value
-                                                                                                                                                binding-type
-                                                                                                                                                make-binding
-                                                                                                                                                sanitize-binding
-                                                                                                                                                arg-check
-                                                                                                                                                no-source
-                                                                                                                                                unannotate
-                                                                                                                                                self-evaluating?
-                                                                                                                                                lexical-var?
-                                                                                                                                                build-lexical-var
-                                                                                                                                                build-top-module
-                                                                                                                                                build-body
-                                                                                                                                                build-letrec
-                                                                                                                                                build-sequence
-                                                                                                                                                build-data
-                                                                                                                                                build-primref
-                                                                                                                                                built-lambda?
-                                                                                                                                                build-lambda
-                                                                                                                                                build-revisit-only
-                                                                                                                                                build-visit-only
-                                                                                                                                                build-cte-install
-                                                                                                                                                build-global-definition
-                                                                                                                                                build-global-assignment
-                                                                                                                                                build-global-reference
-                                                                                                                                                build-lexical-assignment
-                                                                                                                                                build-lexical-reference
-                                                                                                                                                build-conditional
-                                                                                                                                                build-application
-                                                                                                                                                generate-id
-                                                                                                                                                put-import-binding
-                                                                                                                                                get-import-binding
-                                                                                                                                                read-only-binding?
-                                                                                                                                                put-global-definition-hook
-                                                                                                                                                get-global-definition-hook
-                                                                                                                                                put-cte-hook
-                                                                                                                                                gensym-hook
-                                                                                                                                                error-hook
-                                                                                                                                                define-top-level-value-hook
-                                                                                                                                                local-eval-hook
-                                                                                                                                                top-level-eval-hook
-                                                                                                                                                annotation?
-                                                                                                                                                set-syntax-object-wrap!
-                                                                                                                                                set-syntax-object-expression!
-                                                                                                                                                syntax-object-wrap
-                                                                                                                                                syntax-object-expression
-                                                                                                                                                syntax-object?
-                                                                                                                                                make-syntax-object
-                                                                                                                                                noexpand
-                                                                                                                                                let-values
-                                                                                                                                                define-structure
-                                                                                                                                                unless
-                                                                                                                                                when)
-                                                                                                                                               ((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                ("m" top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                ("m" top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                               ("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                             #(top-ribcage
-                                                                                                                                               *top*
-                                                                                                                                               #t)))
-                                                                                                                                        g893
-                                                                                                                                        g892)])
-                                                                                                                                   g888
-                                                                                                                                   g889)))))))
-                                                                                                                     (#%list
-                                                                                                                       '#(syntax-object
-                                                                                                                          $import
-                                                                                                                          ((top)
-                                                                                                                            #(ribcage
-                                                                                                                              #(d
-                                                                                                                                tmid
-                                                                                                                                old-id
-                                                                                                                                tmp
-                                                                                                                                id)
-                                                                                                                              #((top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"
-                                                                                                                                "i"
-                                                                                                                                "i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(mid
-                                                                                                                                d
-                                                                                                                                exports)
-                                                                                                                              #((top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(m
-                                                                                                                                prefix-id)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(orig
-                                                                                                                                import-only?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(m
-                                                                                                                                exports?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              (modspec*
-                                                                                                                                modspec
-                                                                                                                                gen-mid
-                                                                                                                                prefix-drop
-                                                                                                                                prefix-add
-                                                                                                                                difference)
-                                                                                                                              ((top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top)
-                                                                                                                                (top))
-                                                                                                                              ("i" "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"
-                                                                                                                                   "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              #(r)
-                                                                                                                              #((top))
-                                                                                                                              #("i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ()
-                                                                                                                              ()
-                                                                                                                              ())
-                                                                                                                            #(ribcage
-                                                                                                                              #(orig
-                                                                                                                                import-only?)
-                                                                                                                              #((top)
-                                                                                                                                (top))
-                                                                                                                              #("i"
-                                                                                                                                "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              ($import-help
-                                                                                                                                $module-exports)
-                                                                                                                              ((top)
-                                                                                                                                (top))
-                                                                                                                              ("i" "i"))
-                                                                                                                            #(ribcage
-                                                                                                                              (lambda-var-list
-                                                                                                                               gen-var
-                                                                                                                               strip
-                                                                                                                               strip*
-                                                                                                                               strip-annotation
-                                                                                                                               ellipsis?
-                                                                                                                               chi-void
-                                                                                                                               chi-local-syntax
-                                                                                                                               chi-lambda-clause
-                                                                                                                               parse-begin
-                                                                                                                               parse-alias
-                                                                                                                               parse-eval-when
-                                                                                                                               parse-meta
-                                                                                                                               parse-define-syntax
-                                                                                                                               parse-define
-                                                                                                                               parse-import
-                                                                                                                               parse-module
-                                                                                                                               do-import!
-                                                                                                                               lookup-import-label
-                                                                                                                               import-mark-delta
-                                                                                                                               chi-internal
-                                                                                                                               chi-body
-                                                                                                                               chi-macro
-                                                                                                                               chi-set!
-                                                                                                                               chi-application
-                                                                                                                               chi-expr
-                                                                                                                               chi
-                                                                                                                               chi-sequence
-                                                                                                                               chi-meta-frob
-                                                                                                                               chi-frobs
-                                                                                                                               ct-eval/residualize3
-                                                                                                                               ct-eval/residualize2
-                                                                                                                               rt-eval/residualize
-                                                                                                                               initial-mode-set
-                                                                                                                               update-mode-set
-                                                                                                                               do-top-import
-                                                                                                                               vfor-each
-                                                                                                                               vmap
-                                                                                                                               chi-external
-                                                                                                                               check-defined-ids
-                                                                                                                               check-module-exports
-                                                                                                                               id-set-diff
-                                                                                                                               chi-top-module
-                                                                                                                               set-frob-meta?!
-                                                                                                                               set-frob-e!
-                                                                                                                               frob-meta?
-                                                                                                                               frob-e
-                                                                                                                               frob?
-                                                                                                                               make-frob
-                                                                                                                               create-module-binding
-                                                                                                                               set-module-binding-exported!
-                                                                                                                               set-module-binding-val!
-                                                                                                                               set-module-binding-imps!
-                                                                                                                               set-module-binding-label!
-                                                                                                                               set-module-binding-id!
-                                                                                                                               set-module-binding-type!
-                                                                                                                               module-binding-exported
-                                                                                                                               module-binding-val
-                                                                                                                               module-binding-imps
-                                                                                                                               module-binding-label
-                                                                                                                               module-binding-id
-                                                                                                                               module-binding-type
-                                                                                                                               module-binding?
-                                                                                                                               make-module-binding
-                                                                                                                               make-resolved-interface
-                                                                                                                               make-unresolved-interface
-                                                                                                                               set-interface-token!
-                                                                                                                               set-interface-exports!
-                                                                                                                               set-interface-marks!
-                                                                                                                               interface-token
-                                                                                                                               interface-exports
-                                                                                                                               interface-marks
-                                                                                                                               interface?
-                                                                                                                               make-interface
-                                                                                                                               flatten-exports
-                                                                                                                               chi-top
-                                                                                                                               chi-top-sequence
-                                                                                                                               chi-top*
-                                                                                                                               syntax-type
-                                                                                                                               chi-when-list
-                                                                                                                               source-wrap
-                                                                                                                               wrap
-                                                                                                                               bound-id-member?
-                                                                                                                               invalid-ids-error
-                                                                                                                               distinct-bound-ids?
-                                                                                                                               valid-bound-ids?
-                                                                                                                               bound-id=?
-                                                                                                                               help-bound-id=?
-                                                                                                                               literal-id=?
-                                                                                                                               free-id=?
-                                                                                                                               id-var-name
-                                                                                                                               id-var-name-loc
-                                                                                                                               id-var-name&marks
-                                                                                                                               id-var-name-loc&marks
-                                                                                                                               top-id-free-var-name
-                                                                                                                               top-id-bound-var-name
-                                                                                                                               anon
-                                                                                                                               diff-marks
-                                                                                                                               same-marks?
-                                                                                                                               join-subst
-                                                                                                                               join-marks
-                                                                                                                               join-wraps
-                                                                                                                               smart-append
-                                                                                                                               resolved-id-var-name
-                                                                                                                               id->resolved-id
-                                                                                                                               make-resolved-id
-                                                                                                                               make-binding-wrap
-                                                                                                                               store-import-binding
-                                                                                                                               lookup-import-binding-name
-                                                                                                                               extend-ribcage-subst!
-                                                                                                                               extend-ribcage-barrier-help!
-                                                                                                                               extend-ribcage-barrier!
-                                                                                                                               import-extend-ribcage!
-                                                                                                                               extend-ribcage!
-                                                                                                                               make-empty-ribcage
-                                                                                                                               barrier-marker
-                                                                                                                               new-mark
-                                                                                                                               anti-mark
-                                                                                                                               the-anti-mark
-                                                                                                                               set-env-wrap!
-                                                                                                                               set-env-top-ribcage!
-                                                                                                                               env-wrap
-                                                                                                                               env-top-ribcage
-                                                                                                                               env?
-                                                                                                                               make-env
-                                                                                                                               set-import-interface-new-marks!
-                                                                                                                               set-import-interface-interface!
-                                                                                                                               import-interface-new-marks
-                                                                                                                               import-interface-interface
-                                                                                                                               import-interface?
-                                                                                                                               make-import-interface
-                                                                                                                               set-top-ribcage-mutable?!
-                                                                                                                               set-top-ribcage-key!
-                                                                                                                               top-ribcage-mutable?
-                                                                                                                               top-ribcage-key
-                                                                                                                               top-ribcage?
-                                                                                                                               make-top-ribcage
-                                                                                                                               set-ribcage-labels!
-                                                                                                                               set-ribcage-marks!
-                                                                                                                               set-ribcage-symnames!
-                                                                                                                               ribcage-labels
-                                                                                                                               ribcage-marks
-                                                                                                                               ribcage-symnames
-                                                                                                                               ribcage?
-                                                                                                                               make-ribcage
-                                                                                                                               gen-labels
-                                                                                                                               label?
-                                                                                                                               gen-label
-                                                                                                                               set-indirect-label!
-                                                                                                                               get-indirect-label
-                                                                                                                               indirect-label?
-                                                                                                                               gen-indirect-label
-                                                                                                                               anon
-                                                                                                                               only-top-marked?
-                                                                                                                               top-marked?
-                                                                                                                               top-wrap
-                                                                                                                               empty-wrap
-                                                                                                                               wrap-subst
-                                                                                                                               wrap-marks
-                                                                                                                               make-wrap
-                                                                                                                               id-sym-name&marks
-                                                                                                                               id-subst
-                                                                                                                               id-marks
-                                                                                                                               id-sym-name
-                                                                                                                               id?
-                                                                                                                               nonsymbol-id?
-                                                                                                                               global-extend
-                                                                                                                               defer-or-eval-transformer
-                                                                                                                               make-transformer-binding
-                                                                                                                               lookup
-                                                                                                                               lookup*
-                                                                                                                               displaced-lexical-error
-                                                                                                                               displaced-lexical?
-                                                                                                                               extend-var-env*
-                                                                                                                               extend-env*
-                                                                                                                               extend-env
-                                                                                                                               null-env
-                                                                                                                               binding?
-                                                                                                                               set-binding-value!
-                                                                                                                               set-binding-type!
-                                                                                                                               binding-value
-                                                                                                                               binding-type
-                                                                                                                               make-binding
-                                                                                                                               sanitize-binding
-                                                                                                                               arg-check
-                                                                                                                               no-source
-                                                                                                                               unannotate
-                                                                                                                               self-evaluating?
-                                                                                                                               lexical-var?
-                                                                                                                               build-lexical-var
-                                                                                                                               build-top-module
-                                                                                                                               build-body
-                                                                                                                               build-letrec
-                                                                                                                               build-sequence
-                                                                                                                               build-data
-                                                                                                                               build-primref
-                                                                                                                               built-lambda?
-                                                                                                                               build-lambda
-                                                                                                                               build-revisit-only
-                                                                                                                               build-visit-only
-                                                                                                                               build-cte-install
-                                                                                                                               build-global-definition
-                                                                                                                               build-global-assignment
-                                                                                                                               build-global-reference
-                                                                                                                               build-lexical-assignment
-                                                                                                                               build-lexical-reference
-                                                                                                                               build-conditional
-                                                                                                                               build-application
-                                                                                                                               generate-id
-                                                                                                                               put-import-binding
-                                                                                                                               get-import-binding
-                                                                                                                               read-only-binding?
-                                                                                                                               put-global-definition-hook
-                                                                                                                               get-global-definition-hook
-                                                                                                                               put-cte-hook
-                                                                                                                               gensym-hook
-                                                                                                                               error-hook
-                                                                                                                               define-top-level-value-hook
-                                                                                                                               local-eval-hook
-                                                                                                                               top-level-eval-hook
-                                                                                                                               annotation?
-                                                                                                                               set-syntax-object-wrap!
-                                                                                                                               set-syntax-object-expression!
-                                                                                                                               syntax-object-wrap
-                                                                                                                               syntax-object-expression
-                                                                                                                               syntax-object?
-                                                                                                                               make-syntax-object
-                                                                                                                               noexpand
-                                                                                                                               let-values
-                                                                                                                               define-structure
-                                                                                                                               unless
-                                                                                                                               when)
-                                                                                                                              ((top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               ("m" top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               ("m" top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top)
-                                                                                                                               (top))
-                                                                                                                              ("i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"
-                                                                                                                               "i"))
-                                                                                                                            #(top-ribcage
-                                                                                                                              *top*
-                                                                                                                              #t)))
-                                                                                                                       g847
-                                                                                                                       g848
-                                                                                                                       g886))
-                                                                                                                   (if g844
-                                                                                                                       g889
-                                                                                                                       '#f))])
-                                                                                                              g884)
-                                                                                                            (#%syntax-error
-                                                                                                              g883))])
-                                                                                                      (#%$syntax-dispatch
-                                                                                                        g883
-                                                                                                        '(any any
-                                                                                                              each-any
-                                                                                                              each-any
-                                                                                                              each-any)))])
-                                                                                                  ((top-level-value
-                                                                                                     'list)
-                                                                                                    g881
-                                                                                                    (g815
-                                                                                                      g880)
-                                                                                                    g882
-                                                                                                    ((top-level-value
-                                                                                                       'generate-temporaries)
-                                                                                                      g882)
-                                                                                                    ((top-level-value
-                                                                                                       'map)
-                                                                                                      (g813
-                                                                                                        g879)
-                                                                                                      g882)))]))])
-                                                                                        g875)
-                                                                                      ((case-lambda
-                                                                                         [(g894)
-                                                                                          (if (if g894
-                                                                                                  (#%apply
-                                                                                                    (case-lambda
-                                                                                                      [(g895
-                                                                                                        g896)
-                                                                                                       ((top-level-value
-                                                                                                          'identifier?)
-                                                                                                         g896)])
-                                                                                                    g894)
-                                                                                                  '#f)
-                                                                                              (#%apply
-                                                                                                (case-lambda
-                                                                                                  [(g897
-                                                                                                    g898)
-                                                                                                   ((top-level-value
-                                                                                                      'call-with-values)
-                                                                                                     (case-lambda
-                                                                                                       [()
-                                                                                                        (g816
-                                                                                                          g897
-                                                                                                          '#t)])
-                                                                                                     (case-lambda
-                                                                                                       [(g899
-                                                                                                         g900
-                                                                                                         g901)
-                                                                                                        ((case-lambda
-                                                                                                           [(g902)
-                                                                                                            ((case-lambda
-                                                                                                               [(g903)
-                                                                                                                (if g903
-                                                                                                                    (#%apply
-                                                                                                                      (case-lambda
-                                                                                                                        [(g904
-                                                                                                                          g905
-                                                                                                                          g906
-                                                                                                                          g907
-                                                                                                                          g908)
-                                                                                                                         ((top-level-value
-                                                                                                                            'values)
-                                                                                                                           g899
-                                                                                                                           (#%list
-                                                                                                                             '#(syntax-object
-                                                                                                                                begin
-                                                                                                                                ((top)
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(d
-                                                                                                                                      tmid
-                                                                                                                                      old-id
-                                                                                                                                      tmp
-                                                                                                                                      id)
-                                                                                                                                    #((top)
-                                                                                                                                      (top)
-                                                                                                                                      (top)
-                                                                                                                                      (top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"
-                                                                                                                                      "i"
-                                                                                                                                      "i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    ()
-                                                                                                                                    ()
-                                                                                                                                    ())
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(mid
-                                                                                                                                      d
-                                                                                                                                      exports)
-                                                                                                                                    #((top)
-                                                                                                                                      (top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(m
-                                                                                                                                      prefix-id)
-                                                                                                                                    #((top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(orig
-                                                                                                                                      import-only?)
-                                                                                                                                    #((top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    ()
-                                                                                                                                    ()
-                                                                                                                                    ())
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(m
-                                                                                                                                      exports?)
-                                                                                                                                    #((top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    (modspec*
-                                                                                                                                      modspec
-                                                                                                                                      gen-mid
-                                                                                                                                      prefix-drop
-                                                                                                                                      prefix-add
-                                                                                                                                      difference)
-                                                                                                                                    ((top)
-                                                                                                                                      (top)
-                                                                                                                                      (top)
-                                                                                                                                      (top)
-                                                                                                                                      (top)
-                                                                                                                                      (top))
-                                                                                                                                    ("i" "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"
-                                                                                                                                         "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(r)
-                                                                                                                                    #((top))
-                                                                                                                                    #("i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    ()
-                                                                                                                                    ()
-                                                                                                                                    ())
-                                                                                                                                  #(ribcage
-                                                                                                                                    #(orig
-                                                                                                                                      import-only?)
-                                                                                                                                    #((top)
-                                                                                                                                      (top))
-                                                                                                                                    #("i"
-                                                                                                                                      "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    ($import-help
-                                                                                                                                      $module-exports)
-                                                                                                                                    ((top)
-                                                                                                                                      (top))
-                                                                                                                                    ("i" "i"))
-                                                                                                                                  #(ribcage
-                                                                                                                                    (lambda-var-list
-                                                                                                                                     gen-var
-                                                                                                                                     strip
-                                                                                                                                     strip*
-                                                                                                                                     strip-annotation
-                                                                                                                                     ellipsis?
-                                                                                                                                     chi-void
-                                                                                                                                     chi-local-syntax
-                                                                                                                                     chi-lambda-clause
-                                                                                                                                     parse-begin
-                                                                                                                                     parse-alias
-                                                                                                                                     parse-eval-when
-                                                                                                                                     parse-meta
-                                                                                                                                     parse-define-syntax
-                                                                                                                                     parse-define
-                                                                                                                                     parse-import
-                                                                                                                                     parse-module
-                                                                                                                                     do-import!
-                                                                                                                                     lookup-import-label
-                                                                                                                                     import-mark-delta
-                                                                                                                                     chi-internal
-                                                                                                                                     chi-body
-                                                                                                                                     chi-macro
-                                                                                                                                     chi-set!
-                                                                                                                                     chi-application
-                                                                                                                                     chi-expr
-                                                                                                                                     chi
-                                                                                                                                     chi-sequence
-                                                                                                                                     chi-meta-frob
-                                                                                                                                     chi-frobs
-                                                                                                                                     ct-eval/residualize3
-                                                                                                                                     ct-eval/residualize2
-                                                                                                                                     rt-eval/residualize
-                                                                                                                                     initial-mode-set
-                                                                                                                                     update-mode-set
-                                                                                                                                     do-top-import
-                                                                                                                                     vfor-each
-                                                                                                                                     vmap
-                                                                                                                                     chi-external
-                                                                                                                                     check-defined-ids
-                                                                                                                                     check-module-exports
-                                                                                                                                     id-set-diff
-                                                                                                                                     chi-top-module
-                                                                                                                                     set-frob-meta?!
-                                                                                                                                     set-frob-e!
-                                                                                                                                     frob-meta?
-                                                                                                                                     frob-e
-                                                                                                                                     frob?
-                                                                                                                                     make-frob
-                                                                                                                                     create-module-binding
-                                                                                                                                     set-module-binding-exported!
-                                                                                                                                     set-module-binding-val!
-                                                                                                                                     set-module-binding-imps!
-                                                                                                                                     set-module-binding-label!
-                                                                                                                                     set-module-binding-id!
-                                                                                                                                     set-module-binding-type!
-                                                                                                                                     module-binding-exported
-                                                                                                                                     module-binding-val
-                                                                                                                                     module-binding-imps
-                                                                                                                                     module-binding-label
-                                                                                                                                     module-binding-id
-                                                                                                                                     module-binding-type
-                                                                                                                                     module-binding?
-                                                                                                                                     make-module-binding
-                                                                                                                                     make-resolved-interface
-                                                                                                                                     make-unresolved-interface
-                                                                                                                                     set-interface-token!
-                                                                                                                                     set-interface-exports!
-                                                                                                                                     set-interface-marks!
-                                                                                                                                     interface-token
-                                                                                                                                     interface-exports
-                                                                                                                                     interface-marks
-                                                                                                                                     interface?
-                                                                                                                                     make-interface
-                                                                                                                                     flatten-exports
-                                                                                                                                     chi-top
-                                                                                                                                     chi-top-sequence
-                                                                                                                                     chi-top*
-                                                                                                                                     syntax-type
-                                                                                                                                     chi-when-list
-                                                                                                                                     source-wrap
-                                                                                                                                     wrap
-                                                                                                                                     bound-id-member?
-                                                                                                                                     invalid-ids-error
-                                                                                                                                     distinct-bound-ids?
-                                                                                                                                     valid-bound-ids?
-                                                                                                                                     bound-id=?
-                                                                                                                                     help-bound-id=?
-                                                                                                                                     literal-id=?
-                                                                                                                                     free-id=?
-                                                                                                                                     id-var-name
-                                                                                                                                     id-var-name-loc
-                                                                                                                                     id-var-name&marks
-                                                                                                                                     id-var-name-loc&marks
-                                                                                                                                     top-id-free-var-name
-                                                                                                                                     top-id-bound-var-name
-                                                                                                                                     anon
-                                                                                                                                     diff-marks
-                                                                                                                                     same-marks?
-                                                                                                                                     join-subst
-                                                                                                                                     join-marks
-                                                                                                                                     join-wraps
-                                                                                                                                     smart-append
-                                                                                                                                     resolved-id-var-name
-                                                                                                                                     id->resolved-id
-                                                                                                                                     make-resolved-id
-                                                                                                                                     make-binding-wrap
-                                                                                                                                     store-import-binding
-                                                                                                                                     lookup-import-binding-name
-                                                                                                                                     extend-ribcage-subst!
-                                                                                                                                     extend-ribcage-barrier-help!
-                                                                                                                                     extend-ribcage-barrier!
-                                                                                                                                     import-extend-ribcage!
-                                                                                                                                     extend-ribcage!
-                                                                                                                                     make-empty-ribcage
-                                                                                                                                     barrier-marker
-                                                                                                                                     new-mark
-                                                                                                                                     anti-mark
-                                                                                                                                     the-anti-mark
-                                                                                                                                     set-env-wrap!
-                                                                                                                                     set-env-top-ribcage!
-                                                                                                                                     env-wrap
-                                                                                                                                     env-top-ribcage
-                                                                                                                                     env?
-                                                                                                                                     make-env
-                                                                                                                                     set-import-interface-new-marks!
-                                                                                                                                     set-import-interface-interface!
-                                                                                                                                     import-interface-new-marks
-                                                                                                                                     import-interface-interface
-                                                                                                                                     import-interface?
-                                                                                                                                     make-import-interface
-                                                                                                                                     set-top-ribcage-mutable?!
-                                                                                                                                     set-top-ribcage-key!
-                                                                                                                                     top-ribcage-mutable?
-                                                                                                                                     top-ribcage-key
-                                                                                                                                     top-ribcage?
-                                                                                                                                     make-top-ribcage
-                                                                                                                                     set-ribcage-labels!
-                                                                                                                                     set-ribcage-marks!
-                                                                                                                                     set-ribcage-symnames!
-                                                                                                                                     ribcage-labels
-                                                                                                                                     ribcage-marks
-                                                                                                                                     ribcage-symnames
-                                                                                                                                     ribcage?
-                                                                                                                                     make-ribcage
-                                                                                                                                     gen-labels
-                                                                                                                                     label?
-                                                                                                                                     gen-label
-                                                                                                                                     set-indirect-label!
-                                                                                                                                     get-indirect-label
-                                                                                                                                     indirect-label?
-                                                                                                                                     gen-indirect-label
-                                                                                                                                     anon
-                                                                                                                                     only-top-marked?
-                                                                                                                                     top-marked?
-                                                                                                                                     top-wrap
-                                                                                                                                     empty-wrap
-                                                                                                                                     wrap-subst
-                                                                                                                                     wrap-marks
-                                                                                                                                     make-wrap
-                                                                                                                                     id-sym-name&marks
-                                                                                                                                     id-subst
-                                                                                                                                     id-marks
-                                                                                                                                     id-sym-name
-                                                                                                                                     id?
-                                                                                                                                     nonsymbol-id?
-                                                                                                                                     global-extend
-                                                                                                                                     defer-or-eval-transformer
-                                                                                                                                     make-transformer-binding
-                                                                                                                                     lookup
-                                                                                                                                     lookup*
-                                                                                                                                     displaced-lexical-error
-                                                                                                                                     displaced-lexical?
-                                                                                                                                     extend-var-env*
-                                                                                                                                     extend-env*
-                                                                                                                                     extend-env
-                                                                                                                                     null-env
-                                                                                                                                     binding?
-                                                                                                                                     set-binding-value!
-                                                                                                                                     set-binding-type!
-                                                                                                                                     binding-value
-                                                                                                                                     binding-type
-                                                                                                                                     make-binding
-                                                                                                                                     sanitize-binding
-                                                                                                                                     arg-check
-                                                                                                                                     no-source
-                                                                                                                                     unannotate
-                                                                                                                                     self-evaluating?
-                                                                                                                                     lexical-var?
-                                                                                                                                     build-lexical-var
-                                                                                                                                     build-top-module
-                                                                                                                                     build-body
-                                                                                                                                     build-letrec
-                                                                                                                                     build-sequence
-                                                                                                                                     build-data
-                                                                                                                                     build-primref
-                                                                                                                                     built-lambda?
-                                                                                                                                     build-lambda
-                                                                                                                                     build-revisit-only
-                                                                                                                                     build-visit-only
-                                                                                                                                     build-cte-install
-                                                                                                                                     build-global-definition
-                                                                                                                                     build-global-assignment
-                                                                                                                                     build-global-reference
-                                                                                                                                     build-lexical-assignment
-                                                                                                                                     build-lexical-reference
-                                                                                                                                     build-conditional
-                                                                                                                                     build-application
-                                                                                                                                     generate-id
-                                                                                                                                     put-import-binding
-                                                                                                                                     get-import-binding
-                                                                                                                                     read-only-binding?
-                                                                                                                                     put-global-definition-hook
-                                                                                                                                     get-global-definition-hook
-                                                                                                                                     put-cte-hook
-                                                                                                                                     gensym-hook
-                                                                                                                                     error-hook
-                                                                                                                                     define-top-level-value-hook
-                                                                                                                                     local-eval-hook
-                                                                                                                                     top-level-eval-hook
-                                                                                                                                     annotation?
-                                                                                                                                     set-syntax-object-wrap!
-                                                                                                                                     set-syntax-object-expression!
-                                                                                                                                     syntax-object-wrap
-                                                                                                                                     syntax-object-expression
-                                                                                                                                     syntax-object?
-                                                                                                                                     make-syntax-object
-                                                                                                                                     noexpand
-                                                                                                                                     let-values
-                                                                                                                                     define-structure
-                                                                                                                                     unless
-                                                                                                                                     when)
-                                                                                                                                    ((top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     ("m" top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     ("m" top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top)
-                                                                                                                                     (top))
-                                                                                                                                    ("i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"
-                                                                                                                                     "i"))
-                                                                                                                                  #(top-ribcage
-                                                                                                                                    *top*
-                                                                                                                                    #t)))
-                                                                                                                             (#%cons
-                                                                                                                               '#(syntax-object
-                                                                                                                                  $module
-                                                                                                                                  ((top)
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(d
-                                                                                                                                        tmid
-                                                                                                                                        old-id
-                                                                                                                                        tmp
-                                                                                                                                        id)
-                                                                                                                                      #((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(mid
-                                                                                                                                        d
-                                                                                                                                        exports)
-                                                                                                                                      #((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(m
-                                                                                                                                        prefix-id)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(m
-                                                                                                                                        exports?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (modspec*
-                                                                                                                                        modspec
-                                                                                                                                        gen-mid
-                                                                                                                                        prefix-drop
-                                                                                                                                        prefix-add
-                                                                                                                                        difference)
-                                                                                                                                      ((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(r)
-                                                                                                                                      #((top))
-                                                                                                                                      #("i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ($import-help
-                                                                                                                                        $module-exports)
-                                                                                                                                      ((top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (lambda-var-list
-                                                                                                                                       gen-var
-                                                                                                                                       strip
-                                                                                                                                       strip*
-                                                                                                                                       strip-annotation
-                                                                                                                                       ellipsis?
-                                                                                                                                       chi-void
-                                                                                                                                       chi-local-syntax
-                                                                                                                                       chi-lambda-clause
-                                                                                                                                       parse-begin
-                                                                                                                                       parse-alias
-                                                                                                                                       parse-eval-when
-                                                                                                                                       parse-meta
-                                                                                                                                       parse-define-syntax
-                                                                                                                                       parse-define
-                                                                                                                                       parse-import
-                                                                                                                                       parse-module
-                                                                                                                                       do-import!
-                                                                                                                                       lookup-import-label
-                                                                                                                                       import-mark-delta
-                                                                                                                                       chi-internal
-                                                                                                                                       chi-body
-                                                                                                                                       chi-macro
-                                                                                                                                       chi-set!
-                                                                                                                                       chi-application
-                                                                                                                                       chi-expr
-                                                                                                                                       chi
-                                                                                                                                       chi-sequence
-                                                                                                                                       chi-meta-frob
-                                                                                                                                       chi-frobs
-                                                                                                                                       ct-eval/residualize3
-                                                                                                                                       ct-eval/residualize2
-                                                                                                                                       rt-eval/residualize
-                                                                                                                                       initial-mode-set
-                                                                                                                                       update-mode-set
-                                                                                                                                       do-top-import
-                                                                                                                                       vfor-each
-                                                                                                                                       vmap
-                                                                                                                                       chi-external
-                                                                                                                                       check-defined-ids
-                                                                                                                                       check-module-exports
-                                                                                                                                       id-set-diff
-                                                                                                                                       chi-top-module
-                                                                                                                                       set-frob-meta?!
-                                                                                                                                       set-frob-e!
-                                                                                                                                       frob-meta?
-                                                                                                                                       frob-e
-                                                                                                                                       frob?
-                                                                                                                                       make-frob
-                                                                                                                                       create-module-binding
-                                                                                                                                       set-module-binding-exported!
-                                                                                                                                       set-module-binding-val!
-                                                                                                                                       set-module-binding-imps!
-                                                                                                                                       set-module-binding-label!
-                                                                                                                                       set-module-binding-id!
-                                                                                                                                       set-module-binding-type!
-                                                                                                                                       module-binding-exported
-                                                                                                                                       module-binding-val
-                                                                                                                                       module-binding-imps
-                                                                                                                                       module-binding-label
-                                                                                                                                       module-binding-id
-                                                                                                                                       module-binding-type
-                                                                                                                                       module-binding?
-                                                                                                                                       make-module-binding
-                                                                                                                                       make-resolved-interface
-                                                                                                                                       make-unresolved-interface
-                                                                                                                                       set-interface-token!
-                                                                                                                                       set-interface-exports!
-                                                                                                                                       set-interface-marks!
-                                                                                                                                       interface-token
-                                                                                                                                       interface-exports
-                                                                                                                                       interface-marks
-                                                                                                                                       interface?
-                                                                                                                                       make-interface
-                                                                                                                                       flatten-exports
-                                                                                                                                       chi-top
-                                                                                                                                       chi-top-sequence
-                                                                                                                                       chi-top*
-                                                                                                                                       syntax-type
-                                                                                                                                       chi-when-list
-                                                                                                                                       source-wrap
-                                                                                                                                       wrap
-                                                                                                                                       bound-id-member?
-                                                                                                                                       invalid-ids-error
-                                                                                                                                       distinct-bound-ids?
-                                                                                                                                       valid-bound-ids?
-                                                                                                                                       bound-id=?
-                                                                                                                                       help-bound-id=?
-                                                                                                                                       literal-id=?
-                                                                                                                                       free-id=?
-                                                                                                                                       id-var-name
-                                                                                                                                       id-var-name-loc
-                                                                                                                                       id-var-name&marks
-                                                                                                                                       id-var-name-loc&marks
-                                                                                                                                       top-id-free-var-name
-                                                                                                                                       top-id-bound-var-name
-                                                                                                                                       anon
-                                                                                                                                       diff-marks
-                                                                                                                                       same-marks?
-                                                                                                                                       join-subst
-                                                                                                                                       join-marks
-                                                                                                                                       join-wraps
-                                                                                                                                       smart-append
-                                                                                                                                       resolved-id-var-name
-                                                                                                                                       id->resolved-id
-                                                                                                                                       make-resolved-id
-                                                                                                                                       make-binding-wrap
-                                                                                                                                       store-import-binding
-                                                                                                                                       lookup-import-binding-name
-                                                                                                                                       extend-ribcage-subst!
-                                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                                       extend-ribcage-barrier!
-                                                                                                                                       import-extend-ribcage!
-                                                                                                                                       extend-ribcage!
-                                                                                                                                       make-empty-ribcage
-                                                                                                                                       barrier-marker
-                                                                                                                                       new-mark
-                                                                                                                                       anti-mark
-                                                                                                                                       the-anti-mark
-                                                                                                                                       set-env-wrap!
-                                                                                                                                       set-env-top-ribcage!
-                                                                                                                                       env-wrap
-                                                                                                                                       env-top-ribcage
-                                                                                                                                       env?
-                                                                                                                                       make-env
-                                                                                                                                       set-import-interface-new-marks!
-                                                                                                                                       set-import-interface-interface!
-                                                                                                                                       import-interface-new-marks
-                                                                                                                                       import-interface-interface
-                                                                                                                                       import-interface?
-                                                                                                                                       make-import-interface
-                                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                                       set-top-ribcage-key!
-                                                                                                                                       top-ribcage-mutable?
-                                                                                                                                       top-ribcage-key
-                                                                                                                                       top-ribcage?
-                                                                                                                                       make-top-ribcage
-                                                                                                                                       set-ribcage-labels!
-                                                                                                                                       set-ribcage-marks!
-                                                                                                                                       set-ribcage-symnames!
-                                                                                                                                       ribcage-labels
-                                                                                                                                       ribcage-marks
-                                                                                                                                       ribcage-symnames
-                                                                                                                                       ribcage?
-                                                                                                                                       make-ribcage
-                                                                                                                                       gen-labels
-                                                                                                                                       label?
-                                                                                                                                       gen-label
-                                                                                                                                       set-indirect-label!
-                                                                                                                                       get-indirect-label
-                                                                                                                                       indirect-label?
-                                                                                                                                       gen-indirect-label
-                                                                                                                                       anon
-                                                                                                                                       only-top-marked?
-                                                                                                                                       top-marked?
-                                                                                                                                       top-wrap
-                                                                                                                                       empty-wrap
-                                                                                                                                       wrap-subst
-                                                                                                                                       wrap-marks
-                                                                                                                                       make-wrap
-                                                                                                                                       id-sym-name&marks
-                                                                                                                                       id-subst
-                                                                                                                                       id-marks
-                                                                                                                                       id-sym-name
-                                                                                                                                       id?
-                                                                                                                                       nonsymbol-id?
-                                                                                                                                       global-extend
-                                                                                                                                       defer-or-eval-transformer
-                                                                                                                                       make-transformer-binding
-                                                                                                                                       lookup
-                                                                                                                                       lookup*
-                                                                                                                                       displaced-lexical-error
-                                                                                                                                       displaced-lexical?
-                                                                                                                                       extend-var-env*
-                                                                                                                                       extend-env*
-                                                                                                                                       extend-env
-                                                                                                                                       null-env
-                                                                                                                                       binding?
-                                                                                                                                       set-binding-value!
-                                                                                                                                       set-binding-type!
-                                                                                                                                       binding-value
-                                                                                                                                       binding-type
-                                                                                                                                       make-binding
-                                                                                                                                       sanitize-binding
-                                                                                                                                       arg-check
-                                                                                                                                       no-source
-                                                                                                                                       unannotate
-                                                                                                                                       self-evaluating?
-                                                                                                                                       lexical-var?
-                                                                                                                                       build-lexical-var
-                                                                                                                                       build-top-module
-                                                                                                                                       build-body
-                                                                                                                                       build-letrec
-                                                                                                                                       build-sequence
-                                                                                                                                       build-data
-                                                                                                                                       build-primref
-                                                                                                                                       built-lambda?
-                                                                                                                                       build-lambda
-                                                                                                                                       build-revisit-only
-                                                                                                                                       build-visit-only
-                                                                                                                                       build-cte-install
-                                                                                                                                       build-global-definition
-                                                                                                                                       build-global-assignment
-                                                                                                                                       build-global-reference
-                                                                                                                                       build-lexical-assignment
-                                                                                                                                       build-lexical-reference
-                                                                                                                                       build-conditional
-                                                                                                                                       build-application
-                                                                                                                                       generate-id
-                                                                                                                                       put-import-binding
-                                                                                                                                       get-import-binding
-                                                                                                                                       read-only-binding?
-                                                                                                                                       put-global-definition-hook
-                                                                                                                                       get-global-definition-hook
-                                                                                                                                       put-cte-hook
-                                                                                                                                       gensym-hook
-                                                                                                                                       error-hook
-                                                                                                                                       define-top-level-value-hook
-                                                                                                                                       local-eval-hook
-                                                                                                                                       top-level-eval-hook
-                                                                                                                                       annotation?
-                                                                                                                                       set-syntax-object-wrap!
-                                                                                                                                       set-syntax-object-expression!
-                                                                                                                                       syntax-object-wrap
-                                                                                                                                       syntax-object-expression
-                                                                                                                                       syntax-object?
-                                                                                                                                       make-syntax-object
-                                                                                                                                       noexpand
-                                                                                                                                       let-values
-                                                                                                                                       define-structure
-                                                                                                                                       unless
-                                                                                                                                       when)
-                                                                                                                                      ((top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top))
-                                                                                                                                      ("i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"))
-                                                                                                                                    #(top-ribcage
-                                                                                                                                      *top*
-                                                                                                                                      #t)))
-                                                                                                                               (#%cons
-                                                                                                                                 g847
-                                                                                                                                 (#%cons
-                                                                                                                                   g905
-                                                                                                                                   (#%cons
-                                                                                                                                     (#%map
-                                                                                                                                       #%list
-                                                                                                                                       g908
-                                                                                                                                       g907)
-                                                                                                                                     (#%cons
-                                                                                                                                       (#%cons
-                                                                                                                                         '#(syntax-object
-                                                                                                                                            $module
-                                                                                                                                            ((top)
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(d
-                                                                                                                                                  tmid
-                                                                                                                                                  old-id
-                                                                                                                                                  tmp
-                                                                                                                                                  id)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"
-                                                                                                                                                  "i"
-                                                                                                                                                  "i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                ()
-                                                                                                                                                ()
-                                                                                                                                                ())
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(mid
-                                                                                                                                                  d
-                                                                                                                                                  exports)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(m
-                                                                                                                                                  prefix-id)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(orig
-                                                                                                                                                  import-only?)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                ()
-                                                                                                                                                ()
-                                                                                                                                                ())
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(m
-                                                                                                                                                  exports?)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                (modspec*
-                                                                                                                                                  modspec
-                                                                                                                                                  gen-mid
-                                                                                                                                                  prefix-drop
-                                                                                                                                                  prefix-add
-                                                                                                                                                  difference)
-                                                                                                                                                ((top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top)
-                                                                                                                                                  (top))
-                                                                                                                                                ("i" "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(r)
-                                                                                                                                                #((top))
-                                                                                                                                                #("i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                ()
-                                                                                                                                                ()
-                                                                                                                                                ())
-                                                                                                                                              #(ribcage
-                                                                                                                                                #(orig
-                                                                                                                                                  import-only?)
-                                                                                                                                                #((top)
-                                                                                                                                                  (top))
-                                                                                                                                                #("i"
-                                                                                                                                                  "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                ($import-help
-                                                                                                                                                  $module-exports)
-                                                                                                                                                ((top)
-                                                                                                                                                  (top))
-                                                                                                                                                ("i" "i"))
-                                                                                                                                              #(ribcage
-                                                                                                                                                (lambda-var-list
-                                                                                                                                                 gen-var
-                                                                                                                                                 strip
-                                                                                                                                                 strip*
-                                                                                                                                                 strip-annotation
-                                                                                                                                                 ellipsis?
-                                                                                                                                                 chi-void
-                                                                                                                                                 chi-local-syntax
-                                                                                                                                                 chi-lambda-clause
-                                                                                                                                                 parse-begin
-                                                                                                                                                 parse-alias
-                                                                                                                                                 parse-eval-when
-                                                                                                                                                 parse-meta
-                                                                                                                                                 parse-define-syntax
-                                                                                                                                                 parse-define
-                                                                                                                                                 parse-import
-                                                                                                                                                 parse-module
-                                                                                                                                                 do-import!
-                                                                                                                                                 lookup-import-label
-                                                                                                                                                 import-mark-delta
-                                                                                                                                                 chi-internal
-                                                                                                                                                 chi-body
-                                                                                                                                                 chi-macro
-                                                                                                                                                 chi-set!
-                                                                                                                                                 chi-application
-                                                                                                                                                 chi-expr
-                                                                                                                                                 chi
-                                                                                                                                                 chi-sequence
-                                                                                                                                                 chi-meta-frob
-                                                                                                                                                 chi-frobs
-                                                                                                                                                 ct-eval/residualize3
-                                                                                                                                                 ct-eval/residualize2
-                                                                                                                                                 rt-eval/residualize
-                                                                                                                                                 initial-mode-set
-                                                                                                                                                 update-mode-set
-                                                                                                                                                 do-top-import
-                                                                                                                                                 vfor-each
-                                                                                                                                                 vmap
-                                                                                                                                                 chi-external
-                                                                                                                                                 check-defined-ids
-                                                                                                                                                 check-module-exports
-                                                                                                                                                 id-set-diff
-                                                                                                                                                 chi-top-module
-                                                                                                                                                 set-frob-meta?!
-                                                                                                                                                 set-frob-e!
-                                                                                                                                                 frob-meta?
-                                                                                                                                                 frob-e
-                                                                                                                                                 frob?
-                                                                                                                                                 make-frob
-                                                                                                                                                 create-module-binding
-                                                                                                                                                 set-module-binding-exported!
-                                                                                                                                                 set-module-binding-val!
-                                                                                                                                                 set-module-binding-imps!
-                                                                                                                                                 set-module-binding-label!
-                                                                                                                                                 set-module-binding-id!
-                                                                                                                                                 set-module-binding-type!
-                                                                                                                                                 module-binding-exported
-                                                                                                                                                 module-binding-val
-                                                                                                                                                 module-binding-imps
-                                                                                                                                                 module-binding-label
-                                                                                                                                                 module-binding-id
-                                                                                                                                                 module-binding-type
-                                                                                                                                                 module-binding?
-                                                                                                                                                 make-module-binding
-                                                                                                                                                 make-resolved-interface
-                                                                                                                                                 make-unresolved-interface
-                                                                                                                                                 set-interface-token!
-                                                                                                                                                 set-interface-exports!
-                                                                                                                                                 set-interface-marks!
-                                                                                                                                                 interface-token
-                                                                                                                                                 interface-exports
-                                                                                                                                                 interface-marks
-                                                                                                                                                 interface?
-                                                                                                                                                 make-interface
-                                                                                                                                                 flatten-exports
-                                                                                                                                                 chi-top
-                                                                                                                                                 chi-top-sequence
-                                                                                                                                                 chi-top*
-                                                                                                                                                 syntax-type
-                                                                                                                                                 chi-when-list
-                                                                                                                                                 source-wrap
-                                                                                                                                                 wrap
-                                                                                                                                                 bound-id-member?
-                                                                                                                                                 invalid-ids-error
-                                                                                                                                                 distinct-bound-ids?
-                                                                                                                                                 valid-bound-ids?
-                                                                                                                                                 bound-id=?
-                                                                                                                                                 help-bound-id=?
-                                                                                                                                                 literal-id=?
-                                                                                                                                                 free-id=?
-                                                                                                                                                 id-var-name
-                                                                                                                                                 id-var-name-loc
-                                                                                                                                                 id-var-name&marks
-                                                                                                                                                 id-var-name-loc&marks
-                                                                                                                                                 top-id-free-var-name
-                                                                                                                                                 top-id-bound-var-name
-                                                                                                                                                 anon
-                                                                                                                                                 diff-marks
-                                                                                                                                                 same-marks?
-                                                                                                                                                 join-subst
-                                                                                                                                                 join-marks
-                                                                                                                                                 join-wraps
-                                                                                                                                                 smart-append
-                                                                                                                                                 resolved-id-var-name
-                                                                                                                                                 id->resolved-id
-                                                                                                                                                 make-resolved-id
-                                                                                                                                                 make-binding-wrap
-                                                                                                                                                 store-import-binding
-                                                                                                                                                 lookup-import-binding-name
-                                                                                                                                                 extend-ribcage-subst!
-                                                                                                                                                 extend-ribcage-barrier-help!
-                                                                                                                                                 extend-ribcage-barrier!
-                                                                                                                                                 import-extend-ribcage!
-                                                                                                                                                 extend-ribcage!
-                                                                                                                                                 make-empty-ribcage
-                                                                                                                                                 barrier-marker
-                                                                                                                                                 new-mark
-                                                                                                                                                 anti-mark
-                                                                                                                                                 the-anti-mark
-                                                                                                                                                 set-env-wrap!
-                                                                                                                                                 set-env-top-ribcage!
-                                                                                                                                                 env-wrap
-                                                                                                                                                 env-top-ribcage
-                                                                                                                                                 env?
-                                                                                                                                                 make-env
-                                                                                                                                                 set-import-interface-new-marks!
-                                                                                                                                                 set-import-interface-interface!
-                                                                                                                                                 import-interface-new-marks
-                                                                                                                                                 import-interface-interface
-                                                                                                                                                 import-interface?
-                                                                                                                                                 make-import-interface
-                                                                                                                                                 set-top-ribcage-mutable?!
-                                                                                                                                                 set-top-ribcage-key!
-                                                                                                                                                 top-ribcage-mutable?
-                                                                                                                                                 top-ribcage-key
-                                                                                                                                                 top-ribcage?
-                                                                                                                                                 make-top-ribcage
-                                                                                                                                                 set-ribcage-labels!
-                                                                                                                                                 set-ribcage-marks!
-                                                                                                                                                 set-ribcage-symnames!
-                                                                                                                                                 ribcage-labels
-                                                                                                                                                 ribcage-marks
-                                                                                                                                                 ribcage-symnames
-                                                                                                                                                 ribcage?
-                                                                                                                                                 make-ribcage
-                                                                                                                                                 gen-labels
-                                                                                                                                                 label?
-                                                                                                                                                 gen-label
-                                                                                                                                                 set-indirect-label!
-                                                                                                                                                 get-indirect-label
-                                                                                                                                                 indirect-label?
-                                                                                                                                                 gen-indirect-label
-                                                                                                                                                 anon
-                                                                                                                                                 only-top-marked?
-                                                                                                                                                 top-marked?
-                                                                                                                                                 top-wrap
-                                                                                                                                                 empty-wrap
-                                                                                                                                                 wrap-subst
-                                                                                                                                                 wrap-marks
-                                                                                                                                                 make-wrap
-                                                                                                                                                 id-sym-name&marks
-                                                                                                                                                 id-subst
-                                                                                                                                                 id-marks
-                                                                                                                                                 id-sym-name
-                                                                                                                                                 id?
-                                                                                                                                                 nonsymbol-id?
-                                                                                                                                                 global-extend
-                                                                                                                                                 defer-or-eval-transformer
-                                                                                                                                                 make-transformer-binding
-                                                                                                                                                 lookup
-                                                                                                                                                 lookup*
-                                                                                                                                                 displaced-lexical-error
-                                                                                                                                                 displaced-lexical?
-                                                                                                                                                 extend-var-env*
-                                                                                                                                                 extend-env*
-                                                                                                                                                 extend-env
-                                                                                                                                                 null-env
-                                                                                                                                                 binding?
-                                                                                                                                                 set-binding-value!
-                                                                                                                                                 set-binding-type!
-                                                                                                                                                 binding-value
-                                                                                                                                                 binding-type
-                                                                                                                                                 make-binding
-                                                                                                                                                 sanitize-binding
-                                                                                                                                                 arg-check
-                                                                                                                                                 no-source
-                                                                                                                                                 unannotate
-                                                                                                                                                 self-evaluating?
-                                                                                                                                                 lexical-var?
-                                                                                                                                                 build-lexical-var
-                                                                                                                                                 build-top-module
-                                                                                                                                                 build-body
-                                                                                                                                                 build-letrec
-                                                                                                                                                 build-sequence
-                                                                                                                                                 build-data
-                                                                                                                                                 build-primref
-                                                                                                                                                 built-lambda?
-                                                                                                                                                 build-lambda
-                                                                                                                                                 build-revisit-only
-                                                                                                                                                 build-visit-only
-                                                                                                                                                 build-cte-install
-                                                                                                                                                 build-global-definition
-                                                                                                                                                 build-global-assignment
-                                                                                                                                                 build-global-reference
-                                                                                                                                                 build-lexical-assignment
-                                                                                                                                                 build-lexical-reference
-                                                                                                                                                 build-conditional
-                                                                                                                                                 build-application
-                                                                                                                                                 generate-id
-                                                                                                                                                 put-import-binding
-                                                                                                                                                 get-import-binding
-                                                                                                                                                 read-only-binding?
-                                                                                                                                                 put-global-definition-hook
-                                                                                                                                                 get-global-definition-hook
-                                                                                                                                                 put-cte-hook
-                                                                                                                                                 gensym-hook
-                                                                                                                                                 error-hook
-                                                                                                                                                 define-top-level-value-hook
-                                                                                                                                                 local-eval-hook
-                                                                                                                                                 top-level-eval-hook
-                                                                                                                                                 annotation?
-                                                                                                                                                 set-syntax-object-wrap!
-                                                                                                                                                 set-syntax-object-expression!
-                                                                                                                                                 syntax-object-wrap
-                                                                                                                                                 syntax-object-expression
-                                                                                                                                                 syntax-object?
-                                                                                                                                                 make-syntax-object
-                                                                                                                                                 noexpand
-                                                                                                                                                 let-values
-                                                                                                                                                 define-structure
-                                                                                                                                                 unless
-                                                                                                                                                 when)
-                                                                                                                                                ((top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 ("m" top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 ("m" top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top)
-                                                                                                                                                 (top))
-                                                                                                                                                ("i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"))
-                                                                                                                                              #(top-ribcage
-                                                                                                                                                *top*
-                                                                                                                                                #t)))
-                                                                                                                                         (#%cons
-                                                                                                                                           g847
-                                                                                                                                           (#%cons
-                                                                                                                                             g905
-                                                                                                                                             (#%cons
-                                                                                                                                               (#%map
-                                                                                                                                                 #%list
-                                                                                                                                                 g907
-                                                                                                                                                 g906)
-                                                                                                                                               (#%cons
-                                                                                                                                                 g904
-                                                                                                                                                 (#%map
-                                                                                                                                                   (case-lambda
-                                                                                                                                                     [(g909
-                                                                                                                                                       g910)
-                                                                                                                                                      (#%list
-                                                                                                                                                        '#(syntax-object
-                                                                                                                                                           alias
-                                                                                                                                                           ((top)
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(d
-                                                                                                                                                                 tmid
-                                                                                                                                                                 old-id
-                                                                                                                                                                 tmp
-                                                                                                                                                                 id)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(mid
-                                                                                                                                                                 d
-                                                                                                                                                                 exports)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(m
-                                                                                                                                                                 prefix-id)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(orig
-                                                                                                                                                                 import-only?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(m
-                                                                                                                                                                 exports?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               (modspec*
-                                                                                                                                                                 modspec
-                                                                                                                                                                 gen-mid
-                                                                                                                                                                 prefix-drop
-                                                                                                                                                                 prefix-add
-                                                                                                                                                                 difference)
-                                                                                                                                                               ((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               ("i" "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(r)
-                                                                                                                                                               #((top))
-                                                                                                                                                               #("i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(orig
-                                                                                                                                                                 import-only?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ($import-help
-                                                                                                                                                                 $module-exports)
-                                                                                                                                                               ((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               ("i" "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               (lambda-var-list
-                                                                                                                                                                gen-var
-                                                                                                                                                                strip
-                                                                                                                                                                strip*
-                                                                                                                                                                strip-annotation
-                                                                                                                                                                ellipsis?
-                                                                                                                                                                chi-void
-                                                                                                                                                                chi-local-syntax
-                                                                                                                                                                chi-lambda-clause
-                                                                                                                                                                parse-begin
-                                                                                                                                                                parse-alias
-                                                                                                                                                                parse-eval-when
-                                                                                                                                                                parse-meta
-                                                                                                                                                                parse-define-syntax
-                                                                                                                                                                parse-define
-                                                                                                                                                                parse-import
-                                                                                                                                                                parse-module
-                                                                                                                                                                do-import!
-                                                                                                                                                                lookup-import-label
-                                                                                                                                                                import-mark-delta
-                                                                                                                                                                chi-internal
-                                                                                                                                                                chi-body
-                                                                                                                                                                chi-macro
-                                                                                                                                                                chi-set!
-                                                                                                                                                                chi-application
-                                                                                                                                                                chi-expr
-                                                                                                                                                                chi
-                                                                                                                                                                chi-sequence
-                                                                                                                                                                chi-meta-frob
-                                                                                                                                                                chi-frobs
-                                                                                                                                                                ct-eval/residualize3
-                                                                                                                                                                ct-eval/residualize2
-                                                                                                                                                                rt-eval/residualize
-                                                                                                                                                                initial-mode-set
-                                                                                                                                                                update-mode-set
-                                                                                                                                                                do-top-import
-                                                                                                                                                                vfor-each
-                                                                                                                                                                vmap
-                                                                                                                                                                chi-external
-                                                                                                                                                                check-defined-ids
-                                                                                                                                                                check-module-exports
-                                                                                                                                                                id-set-diff
-                                                                                                                                                                chi-top-module
-                                                                                                                                                                set-frob-meta?!
-                                                                                                                                                                set-frob-e!
-                                                                                                                                                                frob-meta?
-                                                                                                                                                                frob-e
-                                                                                                                                                                frob?
-                                                                                                                                                                make-frob
-                                                                                                                                                                create-module-binding
-                                                                                                                                                                set-module-binding-exported!
-                                                                                                                                                                set-module-binding-val!
-                                                                                                                                                                set-module-binding-imps!
-                                                                                                                                                                set-module-binding-label!
-                                                                                                                                                                set-module-binding-id!
-                                                                                                                                                                set-module-binding-type!
-                                                                                                                                                                module-binding-exported
-                                                                                                                                                                module-binding-val
-                                                                                                                                                                module-binding-imps
-                                                                                                                                                                module-binding-label
-                                                                                                                                                                module-binding-id
-                                                                                                                                                                module-binding-type
-                                                                                                                                                                module-binding?
-                                                                                                                                                                make-module-binding
-                                                                                                                                                                make-resolved-interface
-                                                                                                                                                                make-unresolved-interface
-                                                                                                                                                                set-interface-token!
-                                                                                                                                                                set-interface-exports!
-                                                                                                                                                                set-interface-marks!
-                                                                                                                                                                interface-token
-                                                                                                                                                                interface-exports
-                                                                                                                                                                interface-marks
-                                                                                                                                                                interface?
-                                                                                                                                                                make-interface
-                                                                                                                                                                flatten-exports
-                                                                                                                                                                chi-top
-                                                                                                                                                                chi-top-sequence
-                                                                                                                                                                chi-top*
-                                                                                                                                                                syntax-type
-                                                                                                                                                                chi-when-list
-                                                                                                                                                                source-wrap
-                                                                                                                                                                wrap
-                                                                                                                                                                bound-id-member?
-                                                                                                                                                                invalid-ids-error
-                                                                                                                                                                distinct-bound-ids?
-                                                                                                                                                                valid-bound-ids?
-                                                                                                                                                                bound-id=?
-                                                                                                                                                                help-bound-id=?
-                                                                                                                                                                literal-id=?
-                                                                                                                                                                free-id=?
-                                                                                                                                                                id-var-name
-                                                                                                                                                                id-var-name-loc
-                                                                                                                                                                id-var-name&marks
-                                                                                                                                                                id-var-name-loc&marks
-                                                                                                                                                                top-id-free-var-name
-                                                                                                                                                                top-id-bound-var-name
-                                                                                                                                                                anon
-                                                                                                                                                                diff-marks
-                                                                                                                                                                same-marks?
-                                                                                                                                                                join-subst
-                                                                                                                                                                join-marks
-                                                                                                                                                                join-wraps
-                                                                                                                                                                smart-append
-                                                                                                                                                                resolved-id-var-name
-                                                                                                                                                                id->resolved-id
-                                                                                                                                                                make-resolved-id
-                                                                                                                                                                make-binding-wrap
-                                                                                                                                                                store-import-binding
-                                                                                                                                                                lookup-import-binding-name
-                                                                                                                                                                extend-ribcage-subst!
-                                                                                                                                                                extend-ribcage-barrier-help!
-                                                                                                                                                                extend-ribcage-barrier!
-                                                                                                                                                                import-extend-ribcage!
-                                                                                                                                                                extend-ribcage!
-                                                                                                                                                                make-empty-ribcage
-                                                                                                                                                                barrier-marker
-                                                                                                                                                                new-mark
-                                                                                                                                                                anti-mark
-                                                                                                                                                                the-anti-mark
-                                                                                                                                                                set-env-wrap!
-                                                                                                                                                                set-env-top-ribcage!
-                                                                                                                                                                env-wrap
-                                                                                                                                                                env-top-ribcage
-                                                                                                                                                                env?
-                                                                                                                                                                make-env
-                                                                                                                                                                set-import-interface-new-marks!
-                                                                                                                                                                set-import-interface-interface!
-                                                                                                                                                                import-interface-new-marks
-                                                                                                                                                                import-interface-interface
-                                                                                                                                                                import-interface?
-                                                                                                                                                                make-import-interface
-                                                                                                                                                                set-top-ribcage-mutable?!
-                                                                                                                                                                set-top-ribcage-key!
-                                                                                                                                                                top-ribcage-mutable?
-                                                                                                                                                                top-ribcage-key
-                                                                                                                                                                top-ribcage?
-                                                                                                                                                                make-top-ribcage
-                                                                                                                                                                set-ribcage-labels!
-                                                                                                                                                                set-ribcage-marks!
-                                                                                                                                                                set-ribcage-symnames!
-                                                                                                                                                                ribcage-labels
-                                                                                                                                                                ribcage-marks
-                                                                                                                                                                ribcage-symnames
-                                                                                                                                                                ribcage?
-                                                                                                                                                                make-ribcage
-                                                                                                                                                                gen-labels
-                                                                                                                                                                label?
-                                                                                                                                                                gen-label
-                                                                                                                                                                set-indirect-label!
-                                                                                                                                                                get-indirect-label
-                                                                                                                                                                indirect-label?
-                                                                                                                                                                gen-indirect-label
-                                                                                                                                                                anon
-                                                                                                                                                                only-top-marked?
-                                                                                                                                                                top-marked?
-                                                                                                                                                                top-wrap
-                                                                                                                                                                empty-wrap
-                                                                                                                                                                wrap-subst
-                                                                                                                                                                wrap-marks
-                                                                                                                                                                make-wrap
-                                                                                                                                                                id-sym-name&marks
-                                                                                                                                                                id-subst
-                                                                                                                                                                id-marks
-                                                                                                                                                                id-sym-name
-                                                                                                                                                                id?
-                                                                                                                                                                nonsymbol-id?
-                                                                                                                                                                global-extend
-                                                                                                                                                                defer-or-eval-transformer
-                                                                                                                                                                make-transformer-binding
-                                                                                                                                                                lookup
-                                                                                                                                                                lookup*
-                                                                                                                                                                displaced-lexical-error
-                                                                                                                                                                displaced-lexical?
-                                                                                                                                                                extend-var-env*
-                                                                                                                                                                extend-env*
-                                                                                                                                                                extend-env
-                                                                                                                                                                null-env
-                                                                                                                                                                binding?
-                                                                                                                                                                set-binding-value!
-                                                                                                                                                                set-binding-type!
-                                                                                                                                                                binding-value
-                                                                                                                                                                binding-type
-                                                                                                                                                                make-binding
-                                                                                                                                                                sanitize-binding
-                                                                                                                                                                arg-check
-                                                                                                                                                                no-source
-                                                                                                                                                                unannotate
-                                                                                                                                                                self-evaluating?
-                                                                                                                                                                lexical-var?
-                                                                                                                                                                build-lexical-var
-                                                                                                                                                                build-top-module
-                                                                                                                                                                build-body
-                                                                                                                                                                build-letrec
-                                                                                                                                                                build-sequence
-                                                                                                                                                                build-data
-                                                                                                                                                                build-primref
-                                                                                                                                                                built-lambda?
-                                                                                                                                                                build-lambda
-                                                                                                                                                                build-revisit-only
-                                                                                                                                                                build-visit-only
-                                                                                                                                                                build-cte-install
-                                                                                                                                                                build-global-definition
-                                                                                                                                                                build-global-assignment
-                                                                                                                                                                build-global-reference
-                                                                                                                                                                build-lexical-assignment
-                                                                                                                                                                build-lexical-reference
-                                                                                                                                                                build-conditional
-                                                                                                                                                                build-application
-                                                                                                                                                                generate-id
-                                                                                                                                                                put-import-binding
-                                                                                                                                                                get-import-binding
-                                                                                                                                                                read-only-binding?
-                                                                                                                                                                put-global-definition-hook
-                                                                                                                                                                get-global-definition-hook
-                                                                                                                                                                put-cte-hook
-                                                                                                                                                                gensym-hook
-                                                                                                                                                                error-hook
-                                                                                                                                                                define-top-level-value-hook
-                                                                                                                                                                local-eval-hook
-                                                                                                                                                                top-level-eval-hook
-                                                                                                                                                                annotation?
-                                                                                                                                                                set-syntax-object-wrap!
-                                                                                                                                                                set-syntax-object-expression!
-                                                                                                                                                                syntax-object-wrap
-                                                                                                                                                                syntax-object-expression
-                                                                                                                                                                syntax-object?
-                                                                                                                                                                make-syntax-object
-                                                                                                                                                                noexpand
-                                                                                                                                                                let-values
-                                                                                                                                                                define-structure
-                                                                                                                                                                unless
-                                                                                                                                                                when)
-                                                                                                                                                               ((top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                ("m" top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                ("m" top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top))
-                                                                                                                                                               ("i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"))
-                                                                                                                                                             #(top-ribcage
-                                                                                                                                                               *top*
-                                                                                                                                                               #t)))
-                                                                                                                                                        g910
-                                                                                                                                                        g909)])
-                                                                                                                                                   g906
-                                                                                                                                                   g907))))))
-                                                                                                                                       (#%cons
-                                                                                                                                         (#%list
-                                                                                                                                           '#(syntax-object
-                                                                                                                                              $import
-                                                                                                                                              ((top)
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(d
-                                                                                                                                                    tmid
-                                                                                                                                                    old-id
-                                                                                                                                                    tmp
-                                                                                                                                                    id)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  ()
-                                                                                                                                                  ()
-                                                                                                                                                  ())
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(mid
-                                                                                                                                                    d
-                                                                                                                                                    exports)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(m
-                                                                                                                                                    prefix-id)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(orig
-                                                                                                                                                    import-only?)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  ()
-                                                                                                                                                  ()
-                                                                                                                                                  ())
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(m
-                                                                                                                                                    exports?)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  (modspec*
-                                                                                                                                                    modspec
-                                                                                                                                                    gen-mid
-                                                                                                                                                    prefix-drop
-                                                                                                                                                    prefix-add
-                                                                                                                                                    difference)
-                                                                                                                                                  ((top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top)
-                                                                                                                                                    (top))
-                                                                                                                                                  ("i" "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(r)
-                                                                                                                                                  #((top))
-                                                                                                                                                  #("i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  ()
-                                                                                                                                                  ()
-                                                                                                                                                  ())
-                                                                                                                                                #(ribcage
-                                                                                                                                                  #(orig
-                                                                                                                                                    import-only?)
-                                                                                                                                                  #((top)
-                                                                                                                                                    (top))
-                                                                                                                                                  #("i"
-                                                                                                                                                    "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  ($import-help
-                                                                                                                                                    $module-exports)
-                                                                                                                                                  ((top)
-                                                                                                                                                    (top))
-                                                                                                                                                  ("i" "i"))
-                                                                                                                                                #(ribcage
-                                                                                                                                                  (lambda-var-list
-                                                                                                                                                   gen-var
-                                                                                                                                                   strip
-                                                                                                                                                   strip*
-                                                                                                                                                   strip-annotation
-                                                                                                                                                   ellipsis?
-                                                                                                                                                   chi-void
-                                                                                                                                                   chi-local-syntax
-                                                                                                                                                   chi-lambda-clause
-                                                                                                                                                   parse-begin
-                                                                                                                                                   parse-alias
-                                                                                                                                                   parse-eval-when
-                                                                                                                                                   parse-meta
-                                                                                                                                                   parse-define-syntax
-                                                                                                                                                   parse-define
-                                                                                                                                                   parse-import
-                                                                                                                                                   parse-module
-                                                                                                                                                   do-import!
-                                                                                                                                                   lookup-import-label
-                                                                                                                                                   import-mark-delta
-                                                                                                                                                   chi-internal
-                                                                                                                                                   chi-body
-                                                                                                                                                   chi-macro
-                                                                                                                                                   chi-set!
-                                                                                                                                                   chi-application
-                                                                                                                                                   chi-expr
-                                                                                                                                                   chi
-                                                                                                                                                   chi-sequence
-                                                                                                                                                   chi-meta-frob
-                                                                                                                                                   chi-frobs
-                                                                                                                                                   ct-eval/residualize3
-                                                                                                                                                   ct-eval/residualize2
-                                                                                                                                                   rt-eval/residualize
-                                                                                                                                                   initial-mode-set
-                                                                                                                                                   update-mode-set
-                                                                                                                                                   do-top-import
-                                                                                                                                                   vfor-each
-                                                                                                                                                   vmap
-                                                                                                                                                   chi-external
-                                                                                                                                                   check-defined-ids
-                                                                                                                                                   check-module-exports
-                                                                                                                                                   id-set-diff
-                                                                                                                                                   chi-top-module
-                                                                                                                                                   set-frob-meta?!
-                                                                                                                                                   set-frob-e!
-                                                                                                                                                   frob-meta?
-                                                                                                                                                   frob-e
-                                                                                                                                                   frob?
-                                                                                                                                                   make-frob
-                                                                                                                                                   create-module-binding
-                                                                                                                                                   set-module-binding-exported!
-                                                                                                                                                   set-module-binding-val!
-                                                                                                                                                   set-module-binding-imps!
-                                                                                                                                                   set-module-binding-label!
-                                                                                                                                                   set-module-binding-id!
-                                                                                                                                                   set-module-binding-type!
-                                                                                                                                                   module-binding-exported
-                                                                                                                                                   module-binding-val
-                                                                                                                                                   module-binding-imps
-                                                                                                                                                   module-binding-label
-                                                                                                                                                   module-binding-id
-                                                                                                                                                   module-binding-type
-                                                                                                                                                   module-binding?
-                                                                                                                                                   make-module-binding
-                                                                                                                                                   make-resolved-interface
-                                                                                                                                                   make-unresolved-interface
-                                                                                                                                                   set-interface-token!
-                                                                                                                                                   set-interface-exports!
-                                                                                                                                                   set-interface-marks!
-                                                                                                                                                   interface-token
-                                                                                                                                                   interface-exports
-                                                                                                                                                   interface-marks
-                                                                                                                                                   interface?
-                                                                                                                                                   make-interface
-                                                                                                                                                   flatten-exports
-                                                                                                                                                   chi-top
-                                                                                                                                                   chi-top-sequence
-                                                                                                                                                   chi-top*
-                                                                                                                                                   syntax-type
-                                                                                                                                                   chi-when-list
-                                                                                                                                                   source-wrap
-                                                                                                                                                   wrap
-                                                                                                                                                   bound-id-member?
-                                                                                                                                                   invalid-ids-error
-                                                                                                                                                   distinct-bound-ids?
-                                                                                                                                                   valid-bound-ids?
-                                                                                                                                                   bound-id=?
-                                                                                                                                                   help-bound-id=?
-                                                                                                                                                   literal-id=?
-                                                                                                                                                   free-id=?
-                                                                                                                                                   id-var-name
-                                                                                                                                                   id-var-name-loc
-                                                                                                                                                   id-var-name&marks
-                                                                                                                                                   id-var-name-loc&marks
-                                                                                                                                                   top-id-free-var-name
-                                                                                                                                                   top-id-bound-var-name
-                                                                                                                                                   anon
-                                                                                                                                                   diff-marks
-                                                                                                                                                   same-marks?
-                                                                                                                                                   join-subst
-                                                                                                                                                   join-marks
-                                                                                                                                                   join-wraps
-                                                                                                                                                   smart-append
-                                                                                                                                                   resolved-id-var-name
-                                                                                                                                                   id->resolved-id
-                                                                                                                                                   make-resolved-id
-                                                                                                                                                   make-binding-wrap
-                                                                                                                                                   store-import-binding
-                                                                                                                                                   lookup-import-binding-name
-                                                                                                                                                   extend-ribcage-subst!
-                                                                                                                                                   extend-ribcage-barrier-help!
-                                                                                                                                                   extend-ribcage-barrier!
-                                                                                                                                                   import-extend-ribcage!
-                                                                                                                                                   extend-ribcage!
-                                                                                                                                                   make-empty-ribcage
-                                                                                                                                                   barrier-marker
-                                                                                                                                                   new-mark
-                                                                                                                                                   anti-mark
-                                                                                                                                                   the-anti-mark
-                                                                                                                                                   set-env-wrap!
-                                                                                                                                                   set-env-top-ribcage!
-                                                                                                                                                   env-wrap
-                                                                                                                                                   env-top-ribcage
-                                                                                                                                                   env?
-                                                                                                                                                   make-env
-                                                                                                                                                   set-import-interface-new-marks!
-                                                                                                                                                   set-import-interface-interface!
-                                                                                                                                                   import-interface-new-marks
-                                                                                                                                                   import-interface-interface
-                                                                                                                                                   import-interface?
-                                                                                                                                                   make-import-interface
-                                                                                                                                                   set-top-ribcage-mutable?!
-                                                                                                                                                   set-top-ribcage-key!
-                                                                                                                                                   top-ribcage-mutable?
-                                                                                                                                                   top-ribcage-key
-                                                                                                                                                   top-ribcage?
-                                                                                                                                                   make-top-ribcage
-                                                                                                                                                   set-ribcage-labels!
-                                                                                                                                                   set-ribcage-marks!
-                                                                                                                                                   set-ribcage-symnames!
-                                                                                                                                                   ribcage-labels
-                                                                                                                                                   ribcage-marks
-                                                                                                                                                   ribcage-symnames
-                                                                                                                                                   ribcage?
-                                                                                                                                                   make-ribcage
-                                                                                                                                                   gen-labels
-                                                                                                                                                   label?
-                                                                                                                                                   gen-label
-                                                                                                                                                   set-indirect-label!
-                                                                                                                                                   get-indirect-label
-                                                                                                                                                   indirect-label?
-                                                                                                                                                   gen-indirect-label
-                                                                                                                                                   anon
-                                                                                                                                                   only-top-marked?
-                                                                                                                                                   top-marked?
-                                                                                                                                                   top-wrap
-                                                                                                                                                   empty-wrap
-                                                                                                                                                   wrap-subst
-                                                                                                                                                   wrap-marks
-                                                                                                                                                   make-wrap
-                                                                                                                                                   id-sym-name&marks
-                                                                                                                                                   id-subst
-                                                                                                                                                   id-marks
-                                                                                                                                                   id-sym-name
-                                                                                                                                                   id?
-                                                                                                                                                   nonsymbol-id?
-                                                                                                                                                   global-extend
-                                                                                                                                                   defer-or-eval-transformer
-                                                                                                                                                   make-transformer-binding
-                                                                                                                                                   lookup
-                                                                                                                                                   lookup*
-                                                                                                                                                   displaced-lexical-error
-                                                                                                                                                   displaced-lexical?
-                                                                                                                                                   extend-var-env*
-                                                                                                                                                   extend-env*
-                                                                                                                                                   extend-env
-                                                                                                                                                   null-env
-                                                                                                                                                   binding?
-                                                                                                                                                   set-binding-value!
-                                                                                                                                                   set-binding-type!
-                                                                                                                                                   binding-value
-                                                                                                                                                   binding-type
-                                                                                                                                                   make-binding
-                                                                                                                                                   sanitize-binding
-                                                                                                                                                   arg-check
-                                                                                                                                                   no-source
-                                                                                                                                                   unannotate
-                                                                                                                                                   self-evaluating?
-                                                                                                                                                   lexical-var?
-                                                                                                                                                   build-lexical-var
-                                                                                                                                                   build-top-module
-                                                                                                                                                   build-body
-                                                                                                                                                   build-letrec
-                                                                                                                                                   build-sequence
-                                                                                                                                                   build-data
-                                                                                                                                                   build-primref
-                                                                                                                                                   built-lambda?
-                                                                                                                                                   build-lambda
-                                                                                                                                                   build-revisit-only
-                                                                                                                                                   build-visit-only
-                                                                                                                                                   build-cte-install
-                                                                                                                                                   build-global-definition
-                                                                                                                                                   build-global-assignment
-                                                                                                                                                   build-global-reference
-                                                                                                                                                   build-lexical-assignment
-                                                                                                                                                   build-lexical-reference
-                                                                                                                                                   build-conditional
-                                                                                                                                                   build-application
-                                                                                                                                                   generate-id
-                                                                                                                                                   put-import-binding
-                                                                                                                                                   get-import-binding
-                                                                                                                                                   read-only-binding?
-                                                                                                                                                   put-global-definition-hook
-                                                                                                                                                   get-global-definition-hook
-                                                                                                                                                   put-cte-hook
-                                                                                                                                                   gensym-hook
-                                                                                                                                                   error-hook
-                                                                                                                                                   define-top-level-value-hook
-                                                                                                                                                   local-eval-hook
-                                                                                                                                                   top-level-eval-hook
-                                                                                                                                                   annotation?
-                                                                                                                                                   set-syntax-object-wrap!
-                                                                                                                                                   set-syntax-object-expression!
-                                                                                                                                                   syntax-object-wrap
-                                                                                                                                                   syntax-object-expression
-                                                                                                                                                   syntax-object?
-                                                                                                                                                   make-syntax-object
-                                                                                                                                                   noexpand
-                                                                                                                                                   let-values
-                                                                                                                                                   define-structure
-                                                                                                                                                   unless
-                                                                                                                                                   when)
-                                                                                                                                                  ((top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   ("m" top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   ("m" top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top)
-                                                                                                                                                   (top))
-                                                                                                                                                  ("i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"))
-                                                                                                                                                #(top-ribcage
-                                                                                                                                                  *top*
-                                                                                                                                                  #t)))
-                                                                                                                                           g847
-                                                                                                                                           g848
-                                                                                                                                           g905)
-                                                                                                                                         (#%map
-                                                                                                                                           (case-lambda
-                                                                                                                                             [(g911
-                                                                                                                                               g912)
-                                                                                                                                              (#%list
-                                                                                                                                                '#(syntax-object
-                                                                                                                                                   alias
-                                                                                                                                                   ((top)
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(d
-                                                                                                                                                         tmid
-                                                                                                                                                         old-id
-                                                                                                                                                         tmp
-                                                                                                                                                         id)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(mid
-                                                                                                                                                         d
-                                                                                                                                                         exports)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(m
-                                                                                                                                                         prefix-id)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(orig
-                                                                                                                                                         import-only?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(m
-                                                                                                                                                         exports?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       (modspec*
-                                                                                                                                                         modspec
-                                                                                                                                                         gen-mid
-                                                                                                                                                         prefix-drop
-                                                                                                                                                         prefix-add
-                                                                                                                                                         difference)
-                                                                                                                                                       ((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                       ("i" "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(r)
-                                                                                                                                                       #((top))
-                                                                                                                                                       #("i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ()
-                                                                                                                                                       ()
-                                                                                                                                                       ())
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       #(orig
-                                                                                                                                                         import-only?)
-                                                                                                                                                       #((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       #("i"
-                                                                                                                                                         "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       ($import-help
-                                                                                                                                                         $module-exports)
-                                                                                                                                                       ((top)
-                                                                                                                                                         (top))
-                                                                                                                                                       ("i" "i"))
-                                                                                                                                                     #(ribcage
-                                                                                                                                                       (lambda-var-list
-                                                                                                                                                        gen-var
-                                                                                                                                                        strip
-                                                                                                                                                        strip*
-                                                                                                                                                        strip-annotation
-                                                                                                                                                        ellipsis?
-                                                                                                                                                        chi-void
-                                                                                                                                                        chi-local-syntax
-                                                                                                                                                        chi-lambda-clause
-                                                                                                                                                        parse-begin
-                                                                                                                                                        parse-alias
-                                                                                                                                                        parse-eval-when
-                                                                                                                                                        parse-meta
-                                                                                                                                                        parse-define-syntax
-                                                                                                                                                        parse-define
-                                                                                                                                                        parse-import
-                                                                                                                                                        parse-module
-                                                                                                                                                        do-import!
-                                                                                                                                                        lookup-import-label
-                                                                                                                                                        import-mark-delta
-                                                                                                                                                        chi-internal
-                                                                                                                                                        chi-body
-                                                                                                                                                        chi-macro
-                                                                                                                                                        chi-set!
-                                                                                                                                                        chi-application
-                                                                                                                                                        chi-expr
-                                                                                                                                                        chi
-                                                                                                                                                        chi-sequence
-                                                                                                                                                        chi-meta-frob
-                                                                                                                                                        chi-frobs
-                                                                                                                                                        ct-eval/residualize3
-                                                                                                                                                        ct-eval/residualize2
-                                                                                                                                                        rt-eval/residualize
-                                                                                                                                                        initial-mode-set
-                                                                                                                                                        update-mode-set
-                                                                                                                                                        do-top-import
-                                                                                                                                                        vfor-each
-                                                                                                                                                        vmap
-                                                                                                                                                        chi-external
-                                                                                                                                                        check-defined-ids
-                                                                                                                                                        check-module-exports
-                                                                                                                                                        id-set-diff
-                                                                                                                                                        chi-top-module
-                                                                                                                                                        set-frob-meta?!
-                                                                                                                                                        set-frob-e!
-                                                                                                                                                        frob-meta?
-                                                                                                                                                        frob-e
-                                                                                                                                                        frob?
-                                                                                                                                                        make-frob
-                                                                                                                                                        create-module-binding
-                                                                                                                                                        set-module-binding-exported!
-                                                                                                                                                        set-module-binding-val!
-                                                                                                                                                        set-module-binding-imps!
-                                                                                                                                                        set-module-binding-label!
-                                                                                                                                                        set-module-binding-id!
-                                                                                                                                                        set-module-binding-type!
-                                                                                                                                                        module-binding-exported
-                                                                                                                                                        module-binding-val
-                                                                                                                                                        module-binding-imps
-                                                                                                                                                        module-binding-label
-                                                                                                                                                        module-binding-id
-                                                                                                                                                        module-binding-type
-                                                                                                                                                        module-binding?
-                                                                                                                                                        make-module-binding
-                                                                                                                                                        make-resolved-interface
-                                                                                                                                                        make-unresolved-interface
-                                                                                                                                                        set-interface-token!
-                                                                                                                                                        set-interface-exports!
-                                                                                                                                                        set-interface-marks!
-                                                                                                                                                        interface-token
-                                                                                                                                                        interface-exports
-                                                                                                                                                        interface-marks
-                                                                                                                                                        interface?
-                                                                                                                                                        make-interface
-                                                                                                                                                        flatten-exports
-                                                                                                                                                        chi-top
-                                                                                                                                                        chi-top-sequence
-                                                                                                                                                        chi-top*
-                                                                                                                                                        syntax-type
-                                                                                                                                                        chi-when-list
-                                                                                                                                                        source-wrap
-                                                                                                                                                        wrap
-                                                                                                                                                        bound-id-member?
-                                                                                                                                                        invalid-ids-error
-                                                                                                                                                        distinct-bound-ids?
-                                                                                                                                                        valid-bound-ids?
-                                                                                                                                                        bound-id=?
-                                                                                                                                                        help-bound-id=?
-                                                                                                                                                        literal-id=?
-                                                                                                                                                        free-id=?
-                                                                                                                                                        id-var-name
-                                                                                                                                                        id-var-name-loc
-                                                                                                                                                        id-var-name&marks
-                                                                                                                                                        id-var-name-loc&marks
-                                                                                                                                                        top-id-free-var-name
-                                                                                                                                                        top-id-bound-var-name
-                                                                                                                                                        anon
-                                                                                                                                                        diff-marks
-                                                                                                                                                        same-marks?
-                                                                                                                                                        join-subst
-                                                                                                                                                        join-marks
-                                                                                                                                                        join-wraps
-                                                                                                                                                        smart-append
-                                                                                                                                                        resolved-id-var-name
-                                                                                                                                                        id->resolved-id
-                                                                                                                                                        make-resolved-id
-                                                                                                                                                        make-binding-wrap
-                                                                                                                                                        store-import-binding
-                                                                                                                                                        lookup-import-binding-name
-                                                                                                                                                        extend-ribcage-subst!
-                                                                                                                                                        extend-ribcage-barrier-help!
-                                                                                                                                                        extend-ribcage-barrier!
-                                                                                                                                                        import-extend-ribcage!
-                                                                                                                                                        extend-ribcage!
-                                                                                                                                                        make-empty-ribcage
-                                                                                                                                                        barrier-marker
-                                                                                                                                                        new-mark
-                                                                                                                                                        anti-mark
-                                                                                                                                                        the-anti-mark
-                                                                                                                                                        set-env-wrap!
-                                                                                                                                                        set-env-top-ribcage!
-                                                                                                                                                        env-wrap
-                                                                                                                                                        env-top-ribcage
-                                                                                                                                                        env?
-                                                                                                                                                        make-env
-                                                                                                                                                        set-import-interface-new-marks!
-                                                                                                                                                        set-import-interface-interface!
-                                                                                                                                                        import-interface-new-marks
-                                                                                                                                                        import-interface-interface
-                                                                                                                                                        import-interface?
-                                                                                                                                                        make-import-interface
-                                                                                                                                                        set-top-ribcage-mutable?!
-                                                                                                                                                        set-top-ribcage-key!
-                                                                                                                                                        top-ribcage-mutable?
-                                                                                                                                                        top-ribcage-key
-                                                                                                                                                        top-ribcage?
-                                                                                                                                                        make-top-ribcage
-                                                                                                                                                        set-ribcage-labels!
-                                                                                                                                                        set-ribcage-marks!
-                                                                                                                                                        set-ribcage-symnames!
-                                                                                                                                                        ribcage-labels
-                                                                                                                                                        ribcage-marks
-                                                                                                                                                        ribcage-symnames
-                                                                                                                                                        ribcage?
-                                                                                                                                                        make-ribcage
-                                                                                                                                                        gen-labels
-                                                                                                                                                        label?
-                                                                                                                                                        gen-label
-                                                                                                                                                        set-indirect-label!
-                                                                                                                                                        get-indirect-label
-                                                                                                                                                        indirect-label?
-                                                                                                                                                        gen-indirect-label
-                                                                                                                                                        anon
-                                                                                                                                                        only-top-marked?
-                                                                                                                                                        top-marked?
-                                                                                                                                                        top-wrap
-                                                                                                                                                        empty-wrap
-                                                                                                                                                        wrap-subst
-                                                                                                                                                        wrap-marks
-                                                                                                                                                        make-wrap
-                                                                                                                                                        id-sym-name&marks
-                                                                                                                                                        id-subst
-                                                                                                                                                        id-marks
-                                                                                                                                                        id-sym-name
-                                                                                                                                                        id?
-                                                                                                                                                        nonsymbol-id?
-                                                                                                                                                        global-extend
-                                                                                                                                                        defer-or-eval-transformer
-                                                                                                                                                        make-transformer-binding
-                                                                                                                                                        lookup
-                                                                                                                                                        lookup*
-                                                                                                                                                        displaced-lexical-error
-                                                                                                                                                        displaced-lexical?
-                                                                                                                                                        extend-var-env*
-                                                                                                                                                        extend-env*
-                                                                                                                                                        extend-env
-                                                                                                                                                        null-env
-                                                                                                                                                        binding?
-                                                                                                                                                        set-binding-value!
-                                                                                                                                                        set-binding-type!
-                                                                                                                                                        binding-value
-                                                                                                                                                        binding-type
-                                                                                                                                                        make-binding
-                                                                                                                                                        sanitize-binding
-                                                                                                                                                        arg-check
-                                                                                                                                                        no-source
-                                                                                                                                                        unannotate
-                                                                                                                                                        self-evaluating?
-                                                                                                                                                        lexical-var?
-                                                                                                                                                        build-lexical-var
-                                                                                                                                                        build-top-module
-                                                                                                                                                        build-body
-                                                                                                                                                        build-letrec
-                                                                                                                                                        build-sequence
-                                                                                                                                                        build-data
-                                                                                                                                                        build-primref
-                                                                                                                                                        built-lambda?
-                                                                                                                                                        build-lambda
-                                                                                                                                                        build-revisit-only
-                                                                                                                                                        build-visit-only
-                                                                                                                                                        build-cte-install
-                                                                                                                                                        build-global-definition
-                                                                                                                                                        build-global-assignment
-                                                                                                                                                        build-global-reference
-                                                                                                                                                        build-lexical-assignment
-                                                                                                                                                        build-lexical-reference
-                                                                                                                                                        build-conditional
-                                                                                                                                                        build-application
-                                                                                                                                                        generate-id
-                                                                                                                                                        put-import-binding
-                                                                                                                                                        get-import-binding
-                                                                                                                                                        read-only-binding?
-                                                                                                                                                        put-global-definition-hook
-                                                                                                                                                        get-global-definition-hook
-                                                                                                                                                        put-cte-hook
-                                                                                                                                                        gensym-hook
-                                                                                                                                                        error-hook
-                                                                                                                                                        define-top-level-value-hook
-                                                                                                                                                        local-eval-hook
-                                                                                                                                                        top-level-eval-hook
-                                                                                                                                                        annotation?
-                                                                                                                                                        set-syntax-object-wrap!
-                                                                                                                                                        set-syntax-object-expression!
-                                                                                                                                                        syntax-object-wrap
-                                                                                                                                                        syntax-object-expression
-                                                                                                                                                        syntax-object?
-                                                                                                                                                        make-syntax-object
-                                                                                                                                                        noexpand
-                                                                                                                                                        let-values
-                                                                                                                                                        define-structure
-                                                                                                                                                        unless
-                                                                                                                                                        when)
-                                                                                                                                                       ((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        ("m" top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        ("m" top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                       ("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                     #(top-ribcage
-                                                                                                                                                       *top*
-                                                                                                                                                       #t)))
-                                                                                                                                                g912
-                                                                                                                                                g911)])
-                                                                                                                                           g907
-                                                                                                                                           g908)))))))
-                                                                                                                             (#%list
-                                                                                                                               '#(syntax-object
-                                                                                                                                  $import
-                                                                                                                                  ((top)
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(d
-                                                                                                                                        tmid
-                                                                                                                                        old-id
-                                                                                                                                        tmp
-                                                                                                                                        id)
-                                                                                                                                      #((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(mid
-                                                                                                                                        d
-                                                                                                                                        exports)
-                                                                                                                                      #((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(m
-                                                                                                                                        prefix-id)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(m
-                                                                                                                                        exports?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (modspec*
-                                                                                                                                        modspec
-                                                                                                                                        gen-mid
-                                                                                                                                        prefix-drop
-                                                                                                                                        prefix-add
-                                                                                                                                        difference)
-                                                                                                                                      ((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(r)
-                                                                                                                                      #((top))
-                                                                                                                                      #("i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ($import-help
-                                                                                                                                        $module-exports)
-                                                                                                                                      ((top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (lambda-var-list
-                                                                                                                                       gen-var
-                                                                                                                                       strip
-                                                                                                                                       strip*
-                                                                                                                                       strip-annotation
-                                                                                                                                       ellipsis?
-                                                                                                                                       chi-void
-                                                                                                                                       chi-local-syntax
-                                                                                                                                       chi-lambda-clause
-                                                                                                                                       parse-begin
-                                                                                                                                       parse-alias
-                                                                                                                                       parse-eval-when
-                                                                                                                                       parse-meta
-                                                                                                                                       parse-define-syntax
-                                                                                                                                       parse-define
-                                                                                                                                       parse-import
-                                                                                                                                       parse-module
-                                                                                                                                       do-import!
-                                                                                                                                       lookup-import-label
-                                                                                                                                       import-mark-delta
-                                                                                                                                       chi-internal
-                                                                                                                                       chi-body
-                                                                                                                                       chi-macro
-                                                                                                                                       chi-set!
-                                                                                                                                       chi-application
-                                                                                                                                       chi-expr
-                                                                                                                                       chi
-                                                                                                                                       chi-sequence
-                                                                                                                                       chi-meta-frob
-                                                                                                                                       chi-frobs
-                                                                                                                                       ct-eval/residualize3
-                                                                                                                                       ct-eval/residualize2
-                                                                                                                                       rt-eval/residualize
-                                                                                                                                       initial-mode-set
-                                                                                                                                       update-mode-set
-                                                                                                                                       do-top-import
-                                                                                                                                       vfor-each
-                                                                                                                                       vmap
-                                                                                                                                       chi-external
-                                                                                                                                       check-defined-ids
-                                                                                                                                       check-module-exports
-                                                                                                                                       id-set-diff
-                                                                                                                                       chi-top-module
-                                                                                                                                       set-frob-meta?!
-                                                                                                                                       set-frob-e!
-                                                                                                                                       frob-meta?
-                                                                                                                                       frob-e
-                                                                                                                                       frob?
-                                                                                                                                       make-frob
-                                                                                                                                       create-module-binding
-                                                                                                                                       set-module-binding-exported!
-                                                                                                                                       set-module-binding-val!
-                                                                                                                                       set-module-binding-imps!
-                                                                                                                                       set-module-binding-label!
-                                                                                                                                       set-module-binding-id!
-                                                                                                                                       set-module-binding-type!
-                                                                                                                                       module-binding-exported
-                                                                                                                                       module-binding-val
-                                                                                                                                       module-binding-imps
-                                                                                                                                       module-binding-label
-                                                                                                                                       module-binding-id
-                                                                                                                                       module-binding-type
-                                                                                                                                       module-binding?
-                                                                                                                                       make-module-binding
-                                                                                                                                       make-resolved-interface
-                                                                                                                                       make-unresolved-interface
-                                                                                                                                       set-interface-token!
-                                                                                                                                       set-interface-exports!
-                                                                                                                                       set-interface-marks!
-                                                                                                                                       interface-token
-                                                                                                                                       interface-exports
-                                                                                                                                       interface-marks
-                                                                                                                                       interface?
-                                                                                                                                       make-interface
-                                                                                                                                       flatten-exports
-                                                                                                                                       chi-top
-                                                                                                                                       chi-top-sequence
-                                                                                                                                       chi-top*
-                                                                                                                                       syntax-type
-                                                                                                                                       chi-when-list
-                                                                                                                                       source-wrap
-                                                                                                                                       wrap
-                                                                                                                                       bound-id-member?
-                                                                                                                                       invalid-ids-error
-                                                                                                                                       distinct-bound-ids?
-                                                                                                                                       valid-bound-ids?
-                                                                                                                                       bound-id=?
-                                                                                                                                       help-bound-id=?
-                                                                                                                                       literal-id=?
-                                                                                                                                       free-id=?
-                                                                                                                                       id-var-name
-                                                                                                                                       id-var-name-loc
-                                                                                                                                       id-var-name&marks
-                                                                                                                                       id-var-name-loc&marks
-                                                                                                                                       top-id-free-var-name
-                                                                                                                                       top-id-bound-var-name
-                                                                                                                                       anon
-                                                                                                                                       diff-marks
-                                                                                                                                       same-marks?
-                                                                                                                                       join-subst
-                                                                                                                                       join-marks
-                                                                                                                                       join-wraps
-                                                                                                                                       smart-append
-                                                                                                                                       resolved-id-var-name
-                                                                                                                                       id->resolved-id
-                                                                                                                                       make-resolved-id
-                                                                                                                                       make-binding-wrap
-                                                                                                                                       store-import-binding
-                                                                                                                                       lookup-import-binding-name
-                                                                                                                                       extend-ribcage-subst!
-                                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                                       extend-ribcage-barrier!
-                                                                                                                                       import-extend-ribcage!
-                                                                                                                                       extend-ribcage!
-                                                                                                                                       make-empty-ribcage
-                                                                                                                                       barrier-marker
-                                                                                                                                       new-mark
-                                                                                                                                       anti-mark
-                                                                                                                                       the-anti-mark
-                                                                                                                                       set-env-wrap!
-                                                                                                                                       set-env-top-ribcage!
-                                                                                                                                       env-wrap
-                                                                                                                                       env-top-ribcage
-                                                                                                                                       env?
-                                                                                                                                       make-env
-                                                                                                                                       set-import-interface-new-marks!
-                                                                                                                                       set-import-interface-interface!
-                                                                                                                                       import-interface-new-marks
-                                                                                                                                       import-interface-interface
-                                                                                                                                       import-interface?
-                                                                                                                                       make-import-interface
-                                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                                       set-top-ribcage-key!
-                                                                                                                                       top-ribcage-mutable?
-                                                                                                                                       top-ribcage-key
-                                                                                                                                       top-ribcage?
-                                                                                                                                       make-top-ribcage
-                                                                                                                                       set-ribcage-labels!
-                                                                                                                                       set-ribcage-marks!
-                                                                                                                                       set-ribcage-symnames!
-                                                                                                                                       ribcage-labels
-                                                                                                                                       ribcage-marks
-                                                                                                                                       ribcage-symnames
-                                                                                                                                       ribcage?
-                                                                                                                                       make-ribcage
-                                                                                                                                       gen-labels
-                                                                                                                                       label?
-                                                                                                                                       gen-label
-                                                                                                                                       set-indirect-label!
-                                                                                                                                       get-indirect-label
-                                                                                                                                       indirect-label?
-                                                                                                                                       gen-indirect-label
-                                                                                                                                       anon
-                                                                                                                                       only-top-marked?
-                                                                                                                                       top-marked?
-                                                                                                                                       top-wrap
-                                                                                                                                       empty-wrap
-                                                                                                                                       wrap-subst
-                                                                                                                                       wrap-marks
-                                                                                                                                       make-wrap
-                                                                                                                                       id-sym-name&marks
-                                                                                                                                       id-subst
-                                                                                                                                       id-marks
-                                                                                                                                       id-sym-name
-                                                                                                                                       id?
-                                                                                                                                       nonsymbol-id?
-                                                                                                                                       global-extend
-                                                                                                                                       defer-or-eval-transformer
-                                                                                                                                       make-transformer-binding
-                                                                                                                                       lookup
-                                                                                                                                       lookup*
-                                                                                                                                       displaced-lexical-error
-                                                                                                                                       displaced-lexical?
-                                                                                                                                       extend-var-env*
-                                                                                                                                       extend-env*
-                                                                                                                                       extend-env
-                                                                                                                                       null-env
-                                                                                                                                       binding?
-                                                                                                                                       set-binding-value!
-                                                                                                                                       set-binding-type!
-                                                                                                                                       binding-value
-                                                                                                                                       binding-type
-                                                                                                                                       make-binding
-                                                                                                                                       sanitize-binding
-                                                                                                                                       arg-check
-                                                                                                                                       no-source
-                                                                                                                                       unannotate
-                                                                                                                                       self-evaluating?
-                                                                                                                                       lexical-var?
-                                                                                                                                       build-lexical-var
-                                                                                                                                       build-top-module
-                                                                                                                                       build-body
-                                                                                                                                       build-letrec
-                                                                                                                                       build-sequence
-                                                                                                                                       build-data
-                                                                                                                                       build-primref
-                                                                                                                                       built-lambda?
-                                                                                                                                       build-lambda
-                                                                                                                                       build-revisit-only
-                                                                                                                                       build-visit-only
-                                                                                                                                       build-cte-install
-                                                                                                                                       build-global-definition
-                                                                                                                                       build-global-assignment
-                                                                                                                                       build-global-reference
-                                                                                                                                       build-lexical-assignment
-                                                                                                                                       build-lexical-reference
-                                                                                                                                       build-conditional
-                                                                                                                                       build-application
-                                                                                                                                       generate-id
-                                                                                                                                       put-import-binding
-                                                                                                                                       get-import-binding
-                                                                                                                                       read-only-binding?
-                                                                                                                                       put-global-definition-hook
-                                                                                                                                       get-global-definition-hook
-                                                                                                                                       put-cte-hook
-                                                                                                                                       gensym-hook
-                                                                                                                                       error-hook
-                                                                                                                                       define-top-level-value-hook
-                                                                                                                                       local-eval-hook
-                                                                                                                                       top-level-eval-hook
-                                                                                                                                       annotation?
-                                                                                                                                       set-syntax-object-wrap!
-                                                                                                                                       set-syntax-object-expression!
-                                                                                                                                       syntax-object-wrap
-                                                                                                                                       syntax-object-expression
-                                                                                                                                       syntax-object?
-                                                                                                                                       make-syntax-object
-                                                                                                                                       noexpand
-                                                                                                                                       let-values
-                                                                                                                                       define-structure
-                                                                                                                                       unless
-                                                                                                                                       when)
-                                                                                                                                      ((top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top))
-                                                                                                                                      ("i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"))
-                                                                                                                                    #(top-ribcage
-                                                                                                                                      *top*
-                                                                                                                                      #t)))
-                                                                                                                               g847
-                                                                                                                               g848
-                                                                                                                               g905))
-                                                                                                                           (if g844
-                                                                                                                               g908
-                                                                                                                               '#f))])
-                                                                                                                      g903)
-                                                                                                                    (#%syntax-error
-                                                                                                                      g902))])
-                                                                                                              (#%$syntax-dispatch
-                                                                                                                g902
-                                                                                                                '(any any
-                                                                                                                      each-any
-                                                                                                                      each-any
-                                                                                                                      each-any)))])
-                                                                                                          ((top-level-value
-                                                                                                             'list)
-                                                                                                            g900
-                                                                                                            (g815
-                                                                                                              g899)
-                                                                                                            g901
-                                                                                                            ((top-level-value
-                                                                                                               'generate-temporaries)
-                                                                                                              g901)
-                                                                                                            ((top-level-value
-                                                                                                               'map)
-                                                                                                              (g814
-                                                                                                                g898)
-                                                                                                              g901)))]))])
-                                                                                                g894)
-                                                                                              ((case-lambda
-                                                                                                 [(g913)
-                                                                                                  (if (if g913
-                                                                                                          (#%apply
-                                                                                                            (case-lambda
-                                                                                                              [(g914
-                                                                                                                g915
-                                                                                                                g916)
-                                                                                                               (if ((top-level-value
-                                                                                                                      'andmap)
-                                                                                                                     (top-level-value
-                                                                                                                       'identifier?)
-                                                                                                                     g915)
-                                                                                                                   ((top-level-value
-                                                                                                                      'andmap)
-                                                                                                                     (top-level-value
-                                                                                                                       'identifier?)
-                                                                                                                     g916)
-                                                                                                                   '#f)])
-                                                                                                            g913)
-                                                                                                          '#f)
-                                                                                                      (#%apply
-                                                                                                        (case-lambda
-                                                                                                          [(g917
-                                                                                                            g918
-                                                                                                            g919)
-                                                                                                           ((top-level-value
-                                                                                                              'call-with-values)
-                                                                                                             (case-lambda
-                                                                                                               [()
-                                                                                                                (g816
-                                                                                                                  g917
-                                                                                                                  '#t)])
-                                                                                                             (case-lambda
-                                                                                                               [(g920
-                                                                                                                 g921
-                                                                                                                 g922)
-                                                                                                                ((case-lambda
-                                                                                                                   [(g923)
-                                                                                                                    ((case-lambda
-                                                                                                                       [(g924)
-                                                                                                                        (if g924
-                                                                                                                            (#%apply
-                                                                                                                              (case-lambda
-                                                                                                                                [(g925
-                                                                                                                                  g926
-                                                                                                                                  g927
-                                                                                                                                  g928)
-                                                                                                                                 ((top-level-value
-                                                                                                                                    'values)
-                                                                                                                                   g920
-                                                                                                                                   (#%list
-                                                                                                                                     '#(syntax-object
-                                                                                                                                        begin
-                                                                                                                                        ((top)
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(d
-                                                                                                                                              tmid
-                                                                                                                                              tmp
-                                                                                                                                              other-id)
-                                                                                                                                            #((top)
-                                                                                                                                              (top)
-                                                                                                                                              (top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"
-                                                                                                                                              "i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            ()
-                                                                                                                                            ()
-                                                                                                                                            ())
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(mid
-                                                                                                                                              d
-                                                                                                                                              exports)
-                                                                                                                                            #((top)
-                                                                                                                                              (top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(m
-                                                                                                                                              new-id
-                                                                                                                                              old-id)
-                                                                                                                                            #((top)
-                                                                                                                                              (top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(orig
-                                                                                                                                              import-only?)
-                                                                                                                                            #((top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            ()
-                                                                                                                                            ()
-                                                                                                                                            ())
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(m
-                                                                                                                                              exports?)
-                                                                                                                                            #((top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            (modspec*
-                                                                                                                                              modspec
-                                                                                                                                              gen-mid
-                                                                                                                                              prefix-drop
-                                                                                                                                              prefix-add
-                                                                                                                                              difference)
-                                                                                                                                            ((top)
-                                                                                                                                              (top)
-                                                                                                                                              (top)
-                                                                                                                                              (top)
-                                                                                                                                              (top)
-                                                                                                                                              (top))
-                                                                                                                                            ("i" "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"
-                                                                                                                                                 "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(r)
-                                                                                                                                            #((top))
-                                                                                                                                            #("i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            ()
-                                                                                                                                            ()
-                                                                                                                                            ())
-                                                                                                                                          #(ribcage
-                                                                                                                                            #(orig
-                                                                                                                                              import-only?)
-                                                                                                                                            #((top)
-                                                                                                                                              (top))
-                                                                                                                                            #("i"
-                                                                                                                                              "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            ($import-help
-                                                                                                                                              $module-exports)
-                                                                                                                                            ((top)
-                                                                                                                                              (top))
-                                                                                                                                            ("i" "i"))
-                                                                                                                                          #(ribcage
-                                                                                                                                            (lambda-var-list
-                                                                                                                                             gen-var
-                                                                                                                                             strip
-                                                                                                                                             strip*
-                                                                                                                                             strip-annotation
-                                                                                                                                             ellipsis?
-                                                                                                                                             chi-void
-                                                                                                                                             chi-local-syntax
-                                                                                                                                             chi-lambda-clause
-                                                                                                                                             parse-begin
-                                                                                                                                             parse-alias
-                                                                                                                                             parse-eval-when
-                                                                                                                                             parse-meta
-                                                                                                                                             parse-define-syntax
-                                                                                                                                             parse-define
-                                                                                                                                             parse-import
-                                                                                                                                             parse-module
-                                                                                                                                             do-import!
-                                                                                                                                             lookup-import-label
-                                                                                                                                             import-mark-delta
-                                                                                                                                             chi-internal
-                                                                                                                                             chi-body
-                                                                                                                                             chi-macro
-                                                                                                                                             chi-set!
-                                                                                                                                             chi-application
-                                                                                                                                             chi-expr
-                                                                                                                                             chi
-                                                                                                                                             chi-sequence
-                                                                                                                                             chi-meta-frob
-                                                                                                                                             chi-frobs
-                                                                                                                                             ct-eval/residualize3
-                                                                                                                                             ct-eval/residualize2
-                                                                                                                                             rt-eval/residualize
-                                                                                                                                             initial-mode-set
-                                                                                                                                             update-mode-set
-                                                                                                                                             do-top-import
-                                                                                                                                             vfor-each
-                                                                                                                                             vmap
-                                                                                                                                             chi-external
-                                                                                                                                             check-defined-ids
-                                                                                                                                             check-module-exports
-                                                                                                                                             id-set-diff
-                                                                                                                                             chi-top-module
-                                                                                                                                             set-frob-meta?!
-                                                                                                                                             set-frob-e!
-                                                                                                                                             frob-meta?
-                                                                                                                                             frob-e
-                                                                                                                                             frob?
-                                                                                                                                             make-frob
-                                                                                                                                             create-module-binding
-                                                                                                                                             set-module-binding-exported!
-                                                                                                                                             set-module-binding-val!
-                                                                                                                                             set-module-binding-imps!
-                                                                                                                                             set-module-binding-label!
-                                                                                                                                             set-module-binding-id!
-                                                                                                                                             set-module-binding-type!
-                                                                                                                                             module-binding-exported
-                                                                                                                                             module-binding-val
-                                                                                                                                             module-binding-imps
-                                                                                                                                             module-binding-label
-                                                                                                                                             module-binding-id
-                                                                                                                                             module-binding-type
-                                                                                                                                             module-binding?
-                                                                                                                                             make-module-binding
-                                                                                                                                             make-resolved-interface
-                                                                                                                                             make-unresolved-interface
-                                                                                                                                             set-interface-token!
-                                                                                                                                             set-interface-exports!
-                                                                                                                                             set-interface-marks!
-                                                                                                                                             interface-token
-                                                                                                                                             interface-exports
-                                                                                                                                             interface-marks
-                                                                                                                                             interface?
-                                                                                                                                             make-interface
-                                                                                                                                             flatten-exports
-                                                                                                                                             chi-top
-                                                                                                                                             chi-top-sequence
-                                                                                                                                             chi-top*
-                                                                                                                                             syntax-type
-                                                                                                                                             chi-when-list
-                                                                                                                                             source-wrap
-                                                                                                                                             wrap
-                                                                                                                                             bound-id-member?
-                                                                                                                                             invalid-ids-error
-                                                                                                                                             distinct-bound-ids?
-                                                                                                                                             valid-bound-ids?
-                                                                                                                                             bound-id=?
-                                                                                                                                             help-bound-id=?
-                                                                                                                                             literal-id=?
-                                                                                                                                             free-id=?
-                                                                                                                                             id-var-name
-                                                                                                                                             id-var-name-loc
-                                                                                                                                             id-var-name&marks
-                                                                                                                                             id-var-name-loc&marks
-                                                                                                                                             top-id-free-var-name
-                                                                                                                                             top-id-bound-var-name
-                                                                                                                                             anon
-                                                                                                                                             diff-marks
-                                                                                                                                             same-marks?
-                                                                                                                                             join-subst
-                                                                                                                                             join-marks
-                                                                                                                                             join-wraps
-                                                                                                                                             smart-append
-                                                                                                                                             resolved-id-var-name
-                                                                                                                                             id->resolved-id
-                                                                                                                                             make-resolved-id
-                                                                                                                                             make-binding-wrap
-                                                                                                                                             store-import-binding
-                                                                                                                                             lookup-import-binding-name
-                                                                                                                                             extend-ribcage-subst!
-                                                                                                                                             extend-ribcage-barrier-help!
-                                                                                                                                             extend-ribcage-barrier!
-                                                                                                                                             import-extend-ribcage!
-                                                                                                                                             extend-ribcage!
-                                                                                                                                             make-empty-ribcage
-                                                                                                                                             barrier-marker
-                                                                                                                                             new-mark
-                                                                                                                                             anti-mark
-                                                                                                                                             the-anti-mark
-                                                                                                                                             set-env-wrap!
-                                                                                                                                             set-env-top-ribcage!
-                                                                                                                                             env-wrap
-                                                                                                                                             env-top-ribcage
-                                                                                                                                             env?
-                                                                                                                                             make-env
-                                                                                                                                             set-import-interface-new-marks!
-                                                                                                                                             set-import-interface-interface!
-                                                                                                                                             import-interface-new-marks
-                                                                                                                                             import-interface-interface
-                                                                                                                                             import-interface?
-                                                                                                                                             make-import-interface
-                                                                                                                                             set-top-ribcage-mutable?!
-                                                                                                                                             set-top-ribcage-key!
-                                                                                                                                             top-ribcage-mutable?
-                                                                                                                                             top-ribcage-key
-                                                                                                                                             top-ribcage?
-                                                                                                                                             make-top-ribcage
-                                                                                                                                             set-ribcage-labels!
-                                                                                                                                             set-ribcage-marks!
-                                                                                                                                             set-ribcage-symnames!
-                                                                                                                                             ribcage-labels
-                                                                                                                                             ribcage-marks
-                                                                                                                                             ribcage-symnames
-                                                                                                                                             ribcage?
-                                                                                                                                             make-ribcage
-                                                                                                                                             gen-labels
-                                                                                                                                             label?
-                                                                                                                                             gen-label
-                                                                                                                                             set-indirect-label!
-                                                                                                                                             get-indirect-label
-                                                                                                                                             indirect-label?
-                                                                                                                                             gen-indirect-label
-                                                                                                                                             anon
-                                                                                                                                             only-top-marked?
-                                                                                                                                             top-marked?
-                                                                                                                                             top-wrap
-                                                                                                                                             empty-wrap
-                                                                                                                                             wrap-subst
-                                                                                                                                             wrap-marks
-                                                                                                                                             make-wrap
-                                                                                                                                             id-sym-name&marks
-                                                                                                                                             id-subst
-                                                                                                                                             id-marks
-                                                                                                                                             id-sym-name
-                                                                                                                                             id?
-                                                                                                                                             nonsymbol-id?
-                                                                                                                                             global-extend
-                                                                                                                                             defer-or-eval-transformer
-                                                                                                                                             make-transformer-binding
-                                                                                                                                             lookup
-                                                                                                                                             lookup*
-                                                                                                                                             displaced-lexical-error
-                                                                                                                                             displaced-lexical?
-                                                                                                                                             extend-var-env*
-                                                                                                                                             extend-env*
-                                                                                                                                             extend-env
-                                                                                                                                             null-env
-                                                                                                                                             binding?
-                                                                                                                                             set-binding-value!
-                                                                                                                                             set-binding-type!
-                                                                                                                                             binding-value
-                                                                                                                                             binding-type
-                                                                                                                                             make-binding
-                                                                                                                                             sanitize-binding
-                                                                                                                                             arg-check
-                                                                                                                                             no-source
-                                                                                                                                             unannotate
-                                                                                                                                             self-evaluating?
-                                                                                                                                             lexical-var?
-                                                                                                                                             build-lexical-var
-                                                                                                                                             build-top-module
-                                                                                                                                             build-body
-                                                                                                                                             build-letrec
-                                                                                                                                             build-sequence
-                                                                                                                                             build-data
-                                                                                                                                             build-primref
-                                                                                                                                             built-lambda?
-                                                                                                                                             build-lambda
-                                                                                                                                             build-revisit-only
-                                                                                                                                             build-visit-only
-                                                                                                                                             build-cte-install
-                                                                                                                                             build-global-definition
-                                                                                                                                             build-global-assignment
-                                                                                                                                             build-global-reference
-                                                                                                                                             build-lexical-assignment
-                                                                                                                                             build-lexical-reference
-                                                                                                                                             build-conditional
-                                                                                                                                             build-application
-                                                                                                                                             generate-id
-                                                                                                                                             put-import-binding
-                                                                                                                                             get-import-binding
-                                                                                                                                             read-only-binding?
-                                                                                                                                             put-global-definition-hook
-                                                                                                                                             get-global-definition-hook
-                                                                                                                                             put-cte-hook
-                                                                                                                                             gensym-hook
-                                                                                                                                             error-hook
-                                                                                                                                             define-top-level-value-hook
-                                                                                                                                             local-eval-hook
-                                                                                                                                             top-level-eval-hook
-                                                                                                                                             annotation?
-                                                                                                                                             set-syntax-object-wrap!
-                                                                                                                                             set-syntax-object-expression!
-                                                                                                                                             syntax-object-wrap
-                                                                                                                                             syntax-object-expression
-                                                                                                                                             syntax-object?
-                                                                                                                                             make-syntax-object
-                                                                                                                                             noexpand
-                                                                                                                                             let-values
-                                                                                                                                             define-structure
-                                                                                                                                             unless
-                                                                                                                                             when)
-                                                                                                                                            ((top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             ("m" top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             ("m" top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top)
-                                                                                                                                             (top))
-                                                                                                                                            ("i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"
-                                                                                                                                             "i"))
-                                                                                                                                          #(top-ribcage
-                                                                                                                                            *top*
-                                                                                                                                            #t)))
-                                                                                                                                     (#%cons
-                                                                                                                                       '#(syntax-object
-                                                                                                                                          $module
-                                                                                                                                          ((top)
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(d
-                                                                                                                                                tmid
-                                                                                                                                                tmp
-                                                                                                                                                other-id)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(mid
-                                                                                                                                                d
-                                                                                                                                                exports)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(m
-                                                                                                                                                new-id
-                                                                                                                                                old-id)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(m
-                                                                                                                                                exports?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (modspec*
-                                                                                                                                                modspec
-                                                                                                                                                gen-mid
-                                                                                                                                                prefix-drop
-                                                                                                                                                prefix-add
-                                                                                                                                                difference)
-                                                                                                                                              ((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(r)
-                                                                                                                                              #((top))
-                                                                                                                                              #("i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ($import-help
-                                                                                                                                                $module-exports)
-                                                                                                                                              ((top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (lambda-var-list
-                                                                                                                                               gen-var
-                                                                                                                                               strip
-                                                                                                                                               strip*
-                                                                                                                                               strip-annotation
-                                                                                                                                               ellipsis?
-                                                                                                                                               chi-void
-                                                                                                                                               chi-local-syntax
-                                                                                                                                               chi-lambda-clause
-                                                                                                                                               parse-begin
-                                                                                                                                               parse-alias
-                                                                                                                                               parse-eval-when
-                                                                                                                                               parse-meta
-                                                                                                                                               parse-define-syntax
-                                                                                                                                               parse-define
-                                                                                                                                               parse-import
-                                                                                                                                               parse-module
-                                                                                                                                               do-import!
-                                                                                                                                               lookup-import-label
-                                                                                                                                               import-mark-delta
-                                                                                                                                               chi-internal
-                                                                                                                                               chi-body
-                                                                                                                                               chi-macro
-                                                                                                                                               chi-set!
-                                                                                                                                               chi-application
-                                                                                                                                               chi-expr
-                                                                                                                                               chi
-                                                                                                                                               chi-sequence
-                                                                                                                                               chi-meta-frob
-                                                                                                                                               chi-frobs
-                                                                                                                                               ct-eval/residualize3
-                                                                                                                                               ct-eval/residualize2
-                                                                                                                                               rt-eval/residualize
-                                                                                                                                               initial-mode-set
-                                                                                                                                               update-mode-set
-                                                                                                                                               do-top-import
-                                                                                                                                               vfor-each
-                                                                                                                                               vmap
-                                                                                                                                               chi-external
-                                                                                                                                               check-defined-ids
-                                                                                                                                               check-module-exports
-                                                                                                                                               id-set-diff
-                                                                                                                                               chi-top-module
-                                                                                                                                               set-frob-meta?!
-                                                                                                                                               set-frob-e!
-                                                                                                                                               frob-meta?
-                                                                                                                                               frob-e
-                                                                                                                                               frob?
-                                                                                                                                               make-frob
-                                                                                                                                               create-module-binding
-                                                                                                                                               set-module-binding-exported!
-                                                                                                                                               set-module-binding-val!
-                                                                                                                                               set-module-binding-imps!
-                                                                                                                                               set-module-binding-label!
-                                                                                                                                               set-module-binding-id!
-                                                                                                                                               set-module-binding-type!
-                                                                                                                                               module-binding-exported
-                                                                                                                                               module-binding-val
-                                                                                                                                               module-binding-imps
-                                                                                                                                               module-binding-label
-                                                                                                                                               module-binding-id
-                                                                                                                                               module-binding-type
-                                                                                                                                               module-binding?
-                                                                                                                                               make-module-binding
-                                                                                                                                               make-resolved-interface
-                                                                                                                                               make-unresolved-interface
-                                                                                                                                               set-interface-token!
-                                                                                                                                               set-interface-exports!
-                                                                                                                                               set-interface-marks!
-                                                                                                                                               interface-token
-                                                                                                                                               interface-exports
-                                                                                                                                               interface-marks
-                                                                                                                                               interface?
-                                                                                                                                               make-interface
-                                                                                                                                               flatten-exports
-                                                                                                                                               chi-top
-                                                                                                                                               chi-top-sequence
-                                                                                                                                               chi-top*
-                                                                                                                                               syntax-type
-                                                                                                                                               chi-when-list
-                                                                                                                                               source-wrap
-                                                                                                                                               wrap
-                                                                                                                                               bound-id-member?
-                                                                                                                                               invalid-ids-error
-                                                                                                                                               distinct-bound-ids?
-                                                                                                                                               valid-bound-ids?
-                                                                                                                                               bound-id=?
-                                                                                                                                               help-bound-id=?
-                                                                                                                                               literal-id=?
-                                                                                                                                               free-id=?
-                                                                                                                                               id-var-name
-                                                                                                                                               id-var-name-loc
-                                                                                                                                               id-var-name&marks
-                                                                                                                                               id-var-name-loc&marks
-                                                                                                                                               top-id-free-var-name
-                                                                                                                                               top-id-bound-var-name
-                                                                                                                                               anon
-                                                                                                                                               diff-marks
-                                                                                                                                               same-marks?
-                                                                                                                                               join-subst
-                                                                                                                                               join-marks
-                                                                                                                                               join-wraps
-                                                                                                                                               smart-append
-                                                                                                                                               resolved-id-var-name
-                                                                                                                                               id->resolved-id
-                                                                                                                                               make-resolved-id
-                                                                                                                                               make-binding-wrap
-                                                                                                                                               store-import-binding
-                                                                                                                                               lookup-import-binding-name
-                                                                                                                                               extend-ribcage-subst!
-                                                                                                                                               extend-ribcage-barrier-help!
-                                                                                                                                               extend-ribcage-barrier!
-                                                                                                                                               import-extend-ribcage!
-                                                                                                                                               extend-ribcage!
-                                                                                                                                               make-empty-ribcage
-                                                                                                                                               barrier-marker
-                                                                                                                                               new-mark
-                                                                                                                                               anti-mark
-                                                                                                                                               the-anti-mark
-                                                                                                                                               set-env-wrap!
-                                                                                                                                               set-env-top-ribcage!
-                                                                                                                                               env-wrap
-                                                                                                                                               env-top-ribcage
-                                                                                                                                               env?
-                                                                                                                                               make-env
-                                                                                                                                               set-import-interface-new-marks!
-                                                                                                                                               set-import-interface-interface!
-                                                                                                                                               import-interface-new-marks
-                                                                                                                                               import-interface-interface
-                                                                                                                                               import-interface?
-                                                                                                                                               make-import-interface
-                                                                                                                                               set-top-ribcage-mutable?!
-                                                                                                                                               set-top-ribcage-key!
-                                                                                                                                               top-ribcage-mutable?
-                                                                                                                                               top-ribcage-key
-                                                                                                                                               top-ribcage?
-                                                                                                                                               make-top-ribcage
-                                                                                                                                               set-ribcage-labels!
-                                                                                                                                               set-ribcage-marks!
-                                                                                                                                               set-ribcage-symnames!
-                                                                                                                                               ribcage-labels
-                                                                                                                                               ribcage-marks
-                                                                                                                                               ribcage-symnames
-                                                                                                                                               ribcage?
-                                                                                                                                               make-ribcage
-                                                                                                                                               gen-labels
-                                                                                                                                               label?
-                                                                                                                                               gen-label
-                                                                                                                                               set-indirect-label!
-                                                                                                                                               get-indirect-label
-                                                                                                                                               indirect-label?
-                                                                                                                                               gen-indirect-label
-                                                                                                                                               anon
-                                                                                                                                               only-top-marked?
-                                                                                                                                               top-marked?
-                                                                                                                                               top-wrap
-                                                                                                                                               empty-wrap
-                                                                                                                                               wrap-subst
-                                                                                                                                               wrap-marks
-                                                                                                                                               make-wrap
-                                                                                                                                               id-sym-name&marks
-                                                                                                                                               id-subst
-                                                                                                                                               id-marks
-                                                                                                                                               id-sym-name
-                                                                                                                                               id?
-                                                                                                                                               nonsymbol-id?
-                                                                                                                                               global-extend
-                                                                                                                                               defer-or-eval-transformer
-                                                                                                                                               make-transformer-binding
-                                                                                                                                               lookup
-                                                                                                                                               lookup*
-                                                                                                                                               displaced-lexical-error
-                                                                                                                                               displaced-lexical?
-                                                                                                                                               extend-var-env*
-                                                                                                                                               extend-env*
-                                                                                                                                               extend-env
-                                                                                                                                               null-env
-                                                                                                                                               binding?
-                                                                                                                                               set-binding-value!
-                                                                                                                                               set-binding-type!
-                                                                                                                                               binding-value
-                                                                                                                                               binding-type
-                                                                                                                                               make-binding
-                                                                                                                                               sanitize-binding
-                                                                                                                                               arg-check
-                                                                                                                                               no-source
-                                                                                                                                               unannotate
-                                                                                                                                               self-evaluating?
-                                                                                                                                               lexical-var?
-                                                                                                                                               build-lexical-var
-                                                                                                                                               build-top-module
-                                                                                                                                               build-body
-                                                                                                                                               build-letrec
-                                                                                                                                               build-sequence
-                                                                                                                                               build-data
-                                                                                                                                               build-primref
-                                                                                                                                               built-lambda?
-                                                                                                                                               build-lambda
-                                                                                                                                               build-revisit-only
-                                                                                                                                               build-visit-only
-                                                                                                                                               build-cte-install
-                                                                                                                                               build-global-definition
-                                                                                                                                               build-global-assignment
-                                                                                                                                               build-global-reference
-                                                                                                                                               build-lexical-assignment
-                                                                                                                                               build-lexical-reference
-                                                                                                                                               build-conditional
-                                                                                                                                               build-application
-                                                                                                                                               generate-id
-                                                                                                                                               put-import-binding
-                                                                                                                                               get-import-binding
-                                                                                                                                               read-only-binding?
-                                                                                                                                               put-global-definition-hook
-                                                                                                                                               get-global-definition-hook
-                                                                                                                                               put-cte-hook
-                                                                                                                                               gensym-hook
-                                                                                                                                               error-hook
-                                                                                                                                               define-top-level-value-hook
-                                                                                                                                               local-eval-hook
-                                                                                                                                               top-level-eval-hook
-                                                                                                                                               annotation?
-                                                                                                                                               set-syntax-object-wrap!
-                                                                                                                                               set-syntax-object-expression!
-                                                                                                                                               syntax-object-wrap
-                                                                                                                                               syntax-object-expression
-                                                                                                                                               syntax-object?
-                                                                                                                                               make-syntax-object
-                                                                                                                                               noexpand
-                                                                                                                                               let-values
-                                                                                                                                               define-structure
-                                                                                                                                               unless
-                                                                                                                                               when)
-                                                                                                                                              ((top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top))
-                                                                                                                                              ("i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"))
-                                                                                                                                            #(top-ribcage
-                                                                                                                                              *top*
-                                                                                                                                              #t)))
-                                                                                                                                       (#%cons
-                                                                                                                                         g847
-                                                                                                                                         (#%cons
-                                                                                                                                           g926
-                                                                                                                                           (#%cons
-                                                                                                                                             (#%append
-                                                                                                                                               (#%map
-                                                                                                                                                 #%list
-                                                                                                                                                 g918
-                                                                                                                                                 g927)
-                                                                                                                                               g928)
-                                                                                                                                             (#%cons
-                                                                                                                                               (#%cons
-                                                                                                                                                 '#(syntax-object
-                                                                                                                                                    $module
-                                                                                                                                                    ((top)
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(d
-                                                                                                                                                          tmid
-                                                                                                                                                          tmp
-                                                                                                                                                          other-id)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"
-                                                                                                                                                          "i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        ()
-                                                                                                                                                        ()
-                                                                                                                                                        ())
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(mid
-                                                                                                                                                          d
-                                                                                                                                                          exports)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(m
-                                                                                                                                                          new-id
-                                                                                                                                                          old-id)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(orig
-                                                                                                                                                          import-only?)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        ()
-                                                                                                                                                        ()
-                                                                                                                                                        ())
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(m
-                                                                                                                                                          exports?)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        (modspec*
-                                                                                                                                                          modspec
-                                                                                                                                                          gen-mid
-                                                                                                                                                          prefix-drop
-                                                                                                                                                          prefix-add
-                                                                                                                                                          difference)
-                                                                                                                                                        ((top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top)
-                                                                                                                                                          (top))
-                                                                                                                                                        ("i" "i"
-                                                                                                                                                             "i"
-                                                                                                                                                             "i"
-                                                                                                                                                             "i"
-                                                                                                                                                             "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(r)
-                                                                                                                                                        #((top))
-                                                                                                                                                        #("i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        ()
-                                                                                                                                                        ()
-                                                                                                                                                        ())
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        #(orig
-                                                                                                                                                          import-only?)
-                                                                                                                                                        #((top)
-                                                                                                                                                          (top))
-                                                                                                                                                        #("i"
-                                                                                                                                                          "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        ($import-help
-                                                                                                                                                          $module-exports)
-                                                                                                                                                        ((top)
-                                                                                                                                                          (top))
-                                                                                                                                                        ("i" "i"))
-                                                                                                                                                      #(ribcage
-                                                                                                                                                        (lambda-var-list
-                                                                                                                                                         gen-var
-                                                                                                                                                         strip
-                                                                                                                                                         strip*
-                                                                                                                                                         strip-annotation
-                                                                                                                                                         ellipsis?
-                                                                                                                                                         chi-void
-                                                                                                                                                         chi-local-syntax
-                                                                                                                                                         chi-lambda-clause
-                                                                                                                                                         parse-begin
-                                                                                                                                                         parse-alias
-                                                                                                                                                         parse-eval-when
-                                                                                                                                                         parse-meta
-                                                                                                                                                         parse-define-syntax
-                                                                                                                                                         parse-define
-                                                                                                                                                         parse-import
-                                                                                                                                                         parse-module
-                                                                                                                                                         do-import!
-                                                                                                                                                         lookup-import-label
-                                                                                                                                                         import-mark-delta
-                                                                                                                                                         chi-internal
-                                                                                                                                                         chi-body
-                                                                                                                                                         chi-macro
-                                                                                                                                                         chi-set!
-                                                                                                                                                         chi-application
-                                                                                                                                                         chi-expr
-                                                                                                                                                         chi
-                                                                                                                                                         chi-sequence
-                                                                                                                                                         chi-meta-frob
-                                                                                                                                                         chi-frobs
-                                                                                                                                                         ct-eval/residualize3
-                                                                                                                                                         ct-eval/residualize2
-                                                                                                                                                         rt-eval/residualize
-                                                                                                                                                         initial-mode-set
-                                                                                                                                                         update-mode-set
-                                                                                                                                                         do-top-import
-                                                                                                                                                         vfor-each
-                                                                                                                                                         vmap
-                                                                                                                                                         chi-external
-                                                                                                                                                         check-defined-ids
-                                                                                                                                                         check-module-exports
-                                                                                                                                                         id-set-diff
-                                                                                                                                                         chi-top-module
-                                                                                                                                                         set-frob-meta?!
-                                                                                                                                                         set-frob-e!
-                                                                                                                                                         frob-meta?
-                                                                                                                                                         frob-e
-                                                                                                                                                         frob?
-                                                                                                                                                         make-frob
-                                                                                                                                                         create-module-binding
-                                                                                                                                                         set-module-binding-exported!
-                                                                                                                                                         set-module-binding-val!
-                                                                                                                                                         set-module-binding-imps!
-                                                                                                                                                         set-module-binding-label!
-                                                                                                                                                         set-module-binding-id!
-                                                                                                                                                         set-module-binding-type!
-                                                                                                                                                         module-binding-exported
-                                                                                                                                                         module-binding-val
-                                                                                                                                                         module-binding-imps
-                                                                                                                                                         module-binding-label
-                                                                                                                                                         module-binding-id
-                                                                                                                                                         module-binding-type
-                                                                                                                                                         module-binding?
-                                                                                                                                                         make-module-binding
-                                                                                                                                                         make-resolved-interface
-                                                                                                                                                         make-unresolved-interface
-                                                                                                                                                         set-interface-token!
-                                                                                                                                                         set-interface-exports!
-                                                                                                                                                         set-interface-marks!
-                                                                                                                                                         interface-token
-                                                                                                                                                         interface-exports
-                                                                                                                                                         interface-marks
-                                                                                                                                                         interface?
-                                                                                                                                                         make-interface
-                                                                                                                                                         flatten-exports
-                                                                                                                                                         chi-top
-                                                                                                                                                         chi-top-sequence
-                                                                                                                                                         chi-top*
-                                                                                                                                                         syntax-type
-                                                                                                                                                         chi-when-list
-                                                                                                                                                         source-wrap
-                                                                                                                                                         wrap
-                                                                                                                                                         bound-id-member?
-                                                                                                                                                         invalid-ids-error
-                                                                                                                                                         distinct-bound-ids?
-                                                                                                                                                         valid-bound-ids?
-                                                                                                                                                         bound-id=?
-                                                                                                                                                         help-bound-id=?
-                                                                                                                                                         literal-id=?
-                                                                                                                                                         free-id=?
-                                                                                                                                                         id-var-name
-                                                                                                                                                         id-var-name-loc
-                                                                                                                                                         id-var-name&marks
-                                                                                                                                                         id-var-name-loc&marks
-                                                                                                                                                         top-id-free-var-name
-                                                                                                                                                         top-id-bound-var-name
-                                                                                                                                                         anon
-                                                                                                                                                         diff-marks
-                                                                                                                                                         same-marks?
-                                                                                                                                                         join-subst
-                                                                                                                                                         join-marks
-                                                                                                                                                         join-wraps
-                                                                                                                                                         smart-append
-                                                                                                                                                         resolved-id-var-name
-                                                                                                                                                         id->resolved-id
-                                                                                                                                                         make-resolved-id
-                                                                                                                                                         make-binding-wrap
-                                                                                                                                                         store-import-binding
-                                                                                                                                                         lookup-import-binding-name
-                                                                                                                                                         extend-ribcage-subst!
-                                                                                                                                                         extend-ribcage-barrier-help!
-                                                                                                                                                         extend-ribcage-barrier!
-                                                                                                                                                         import-extend-ribcage!
-                                                                                                                                                         extend-ribcage!
-                                                                                                                                                         make-empty-ribcage
-                                                                                                                                                         barrier-marker
-                                                                                                                                                         new-mark
-                                                                                                                                                         anti-mark
-                                                                                                                                                         the-anti-mark
-                                                                                                                                                         set-env-wrap!
-                                                                                                                                                         set-env-top-ribcage!
-                                                                                                                                                         env-wrap
-                                                                                                                                                         env-top-ribcage
-                                                                                                                                                         env?
-                                                                                                                                                         make-env
-                                                                                                                                                         set-import-interface-new-marks!
-                                                                                                                                                         set-import-interface-interface!
-                                                                                                                                                         import-interface-new-marks
-                                                                                                                                                         import-interface-interface
-                                                                                                                                                         import-interface?
-                                                                                                                                                         make-import-interface
-                                                                                                                                                         set-top-ribcage-mutable?!
-                                                                                                                                                         set-top-ribcage-key!
-                                                                                                                                                         top-ribcage-mutable?
-                                                                                                                                                         top-ribcage-key
-                                                                                                                                                         top-ribcage?
-                                                                                                                                                         make-top-ribcage
-                                                                                                                                                         set-ribcage-labels!
-                                                                                                                                                         set-ribcage-marks!
-                                                                                                                                                         set-ribcage-symnames!
-                                                                                                                                                         ribcage-labels
-                                                                                                                                                         ribcage-marks
-                                                                                                                                                         ribcage-symnames
-                                                                                                                                                         ribcage?
-                                                                                                                                                         make-ribcage
-                                                                                                                                                         gen-labels
-                                                                                                                                                         label?
-                                                                                                                                                         gen-label
-                                                                                                                                                         set-indirect-label!
-                                                                                                                                                         get-indirect-label
-                                                                                                                                                         indirect-label?
-                                                                                                                                                         gen-indirect-label
-                                                                                                                                                         anon
-                                                                                                                                                         only-top-marked?
-                                                                                                                                                         top-marked?
-                                                                                                                                                         top-wrap
-                                                                                                                                                         empty-wrap
-                                                                                                                                                         wrap-subst
-                                                                                                                                                         wrap-marks
-                                                                                                                                                         make-wrap
-                                                                                                                                                         id-sym-name&marks
-                                                                                                                                                         id-subst
-                                                                                                                                                         id-marks
-                                                                                                                                                         id-sym-name
-                                                                                                                                                         id?
-                                                                                                                                                         nonsymbol-id?
-                                                                                                                                                         global-extend
-                                                                                                                                                         defer-or-eval-transformer
-                                                                                                                                                         make-transformer-binding
-                                                                                                                                                         lookup
-                                                                                                                                                         lookup*
-                                                                                                                                                         displaced-lexical-error
-                                                                                                                                                         displaced-lexical?
-                                                                                                                                                         extend-var-env*
-                                                                                                                                                         extend-env*
-                                                                                                                                                         extend-env
-                                                                                                                                                         null-env
-                                                                                                                                                         binding?
-                                                                                                                                                         set-binding-value!
-                                                                                                                                                         set-binding-type!
-                                                                                                                                                         binding-value
-                                                                                                                                                         binding-type
-                                                                                                                                                         make-binding
-                                                                                                                                                         sanitize-binding
-                                                                                                                                                         arg-check
-                                                                                                                                                         no-source
-                                                                                                                                                         unannotate
-                                                                                                                                                         self-evaluating?
-                                                                                                                                                         lexical-var?
-                                                                                                                                                         build-lexical-var
-                                                                                                                                                         build-top-module
-                                                                                                                                                         build-body
-                                                                                                                                                         build-letrec
-                                                                                                                                                         build-sequence
-                                                                                                                                                         build-data
-                                                                                                                                                         build-primref
-                                                                                                                                                         built-lambda?
-                                                                                                                                                         build-lambda
-                                                                                                                                                         build-revisit-only
-                                                                                                                                                         build-visit-only
-                                                                                                                                                         build-cte-install
-                                                                                                                                                         build-global-definition
-                                                                                                                                                         build-global-assignment
-                                                                                                                                                         build-global-reference
-                                                                                                                                                         build-lexical-assignment
-                                                                                                                                                         build-lexical-reference
-                                                                                                                                                         build-conditional
-                                                                                                                                                         build-application
-                                                                                                                                                         generate-id
-                                                                                                                                                         put-import-binding
-                                                                                                                                                         get-import-binding
-                                                                                                                                                         read-only-binding?
-                                                                                                                                                         put-global-definition-hook
-                                                                                                                                                         get-global-definition-hook
-                                                                                                                                                         put-cte-hook
-                                                                                                                                                         gensym-hook
-                                                                                                                                                         error-hook
-                                                                                                                                                         define-top-level-value-hook
-                                                                                                                                                         local-eval-hook
-                                                                                                                                                         top-level-eval-hook
-                                                                                                                                                         annotation?
-                                                                                                                                                         set-syntax-object-wrap!
-                                                                                                                                                         set-syntax-object-expression!
-                                                                                                                                                         syntax-object-wrap
-                                                                                                                                                         syntax-object-expression
-                                                                                                                                                         syntax-object?
-                                                                                                                                                         make-syntax-object
-                                                                                                                                                         noexpand
-                                                                                                                                                         let-values
-                                                                                                                                                         define-structure
-                                                                                                                                                         unless
-                                                                                                                                                         when)
-                                                                                                                                                        ((top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         ("m" top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         ("m" top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top)
-                                                                                                                                                         (top))
-                                                                                                                                                        ("i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                      #(top-ribcage
-                                                                                                                                                        *top*
-                                                                                                                                                        #t)))
-                                                                                                                                                 (#%cons
-                                                                                                                                                   g847
-                                                                                                                                                   (#%cons
-                                                                                                                                                     g926
-                                                                                                                                                     (#%cons
-                                                                                                                                                       (#%append
-                                                                                                                                                         g928
-                                                                                                                                                         (#%map
-                                                                                                                                                           #%list
-                                                                                                                                                           g927
-                                                                                                                                                           g919))
-                                                                                                                                                       (#%cons
-                                                                                                                                                         g925
-                                                                                                                                                         (#%map
-                                                                                                                                                           (case-lambda
-                                                                                                                                                             [(g929
-                                                                                                                                                               g930)
-                                                                                                                                                              (#%list
-                                                                                                                                                                '#(syntax-object
-                                                                                                                                                                   alias
-                                                                                                                                                                   ((top)
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(d
-                                                                                                                                                                         tmid
-                                                                                                                                                                         tmp
-                                                                                                                                                                         other-id)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"
-                                                                                                                                                                         "i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       ()
-                                                                                                                                                                       ()
-                                                                                                                                                                       ())
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(mid
-                                                                                                                                                                         d
-                                                                                                                                                                         exports)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(m
-                                                                                                                                                                         new-id
-                                                                                                                                                                         old-id)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(orig
-                                                                                                                                                                         import-only?)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       ()
-                                                                                                                                                                       ()
-                                                                                                                                                                       ())
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(m
-                                                                                                                                                                         exports?)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       (modspec*
-                                                                                                                                                                         modspec
-                                                                                                                                                                         gen-mid
-                                                                                                                                                                         prefix-drop
-                                                                                                                                                                         prefix-add
-                                                                                                                                                                         difference)
-                                                                                                                                                                       ((top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       ("i" "i"
-                                                                                                                                                                            "i"
-                                                                                                                                                                            "i"
-                                                                                                                                                                            "i"
-                                                                                                                                                                            "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(r)
-                                                                                                                                                                       #((top))
-                                                                                                                                                                       #("i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       ()
-                                                                                                                                                                       ()
-                                                                                                                                                                       ())
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       #(orig
-                                                                                                                                                                         import-only?)
-                                                                                                                                                                       #((top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       #("i"
-                                                                                                                                                                         "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       ($import-help
-                                                                                                                                                                         $module-exports)
-                                                                                                                                                                       ((top)
-                                                                                                                                                                         (top))
-                                                                                                                                                                       ("i" "i"))
-                                                                                                                                                                     #(ribcage
-                                                                                                                                                                       (lambda-var-list
-                                                                                                                                                                        gen-var
-                                                                                                                                                                        strip
-                                                                                                                                                                        strip*
-                                                                                                                                                                        strip-annotation
-                                                                                                                                                                        ellipsis?
-                                                                                                                                                                        chi-void
-                                                                                                                                                                        chi-local-syntax
-                                                                                                                                                                        chi-lambda-clause
-                                                                                                                                                                        parse-begin
-                                                                                                                                                                        parse-alias
-                                                                                                                                                                        parse-eval-when
-                                                                                                                                                                        parse-meta
-                                                                                                                                                                        parse-define-syntax
-                                                                                                                                                                        parse-define
-                                                                                                                                                                        parse-import
-                                                                                                                                                                        parse-module
-                                                                                                                                                                        do-import!
-                                                                                                                                                                        lookup-import-label
-                                                                                                                                                                        import-mark-delta
-                                                                                                                                                                        chi-internal
-                                                                                                                                                                        chi-body
-                                                                                                                                                                        chi-macro
-                                                                                                                                                                        chi-set!
-                                                                                                                                                                        chi-application
-                                                                                                                                                                        chi-expr
-                                                                                                                                                                        chi
-                                                                                                                                                                        chi-sequence
-                                                                                                                                                                        chi-meta-frob
-                                                                                                                                                                        chi-frobs
-                                                                                                                                                                        ct-eval/residualize3
-                                                                                                                                                                        ct-eval/residualize2
-                                                                                                                                                                        rt-eval/residualize
-                                                                                                                                                                        initial-mode-set
-                                                                                                                                                                        update-mode-set
-                                                                                                                                                                        do-top-import
-                                                                                                                                                                        vfor-each
-                                                                                                                                                                        vmap
-                                                                                                                                                                        chi-external
-                                                                                                                                                                        check-defined-ids
-                                                                                                                                                                        check-module-exports
-                                                                                                                                                                        id-set-diff
-                                                                                                                                                                        chi-top-module
-                                                                                                                                                                        set-frob-meta?!
-                                                                                                                                                                        set-frob-e!
-                                                                                                                                                                        frob-meta?
-                                                                                                                                                                        frob-e
-                                                                                                                                                                        frob?
-                                                                                                                                                                        make-frob
-                                                                                                                                                                        create-module-binding
-                                                                                                                                                                        set-module-binding-exported!
-                                                                                                                                                                        set-module-binding-val!
-                                                                                                                                                                        set-module-binding-imps!
-                                                                                                                                                                        set-module-binding-label!
-                                                                                                                                                                        set-module-binding-id!
-                                                                                                                                                                        set-module-binding-type!
-                                                                                                                                                                        module-binding-exported
-                                                                                                                                                                        module-binding-val
-                                                                                                                                                                        module-binding-imps
-                                                                                                                                                                        module-binding-label
-                                                                                                                                                                        module-binding-id
-                                                                                                                                                                        module-binding-type
-                                                                                                                                                                        module-binding?
-                                                                                                                                                                        make-module-binding
-                                                                                                                                                                        make-resolved-interface
-                                                                                                                                                                        make-unresolved-interface
-                                                                                                                                                                        set-interface-token!
-                                                                                                                                                                        set-interface-exports!
-                                                                                                                                                                        set-interface-marks!
-                                                                                                                                                                        interface-token
-                                                                                                                                                                        interface-exports
-                                                                                                                                                                        interface-marks
-                                                                                                                                                                        interface?
-                                                                                                                                                                        make-interface
-                                                                                                                                                                        flatten-exports
-                                                                                                                                                                        chi-top
-                                                                                                                                                                        chi-top-sequence
-                                                                                                                                                                        chi-top*
-                                                                                                                                                                        syntax-type
-                                                                                                                                                                        chi-when-list
-                                                                                                                                                                        source-wrap
-                                                                                                                                                                        wrap
-                                                                                                                                                                        bound-id-member?
-                                                                                                                                                                        invalid-ids-error
-                                                                                                                                                                        distinct-bound-ids?
-                                                                                                                                                                        valid-bound-ids?
-                                                                                                                                                                        bound-id=?
-                                                                                                                                                                        help-bound-id=?
-                                                                                                                                                                        literal-id=?
-                                                                                                                                                                        free-id=?
-                                                                                                                                                                        id-var-name
-                                                                                                                                                                        id-var-name-loc
-                                                                                                                                                                        id-var-name&marks
-                                                                                                                                                                        id-var-name-loc&marks
-                                                                                                                                                                        top-id-free-var-name
-                                                                                                                                                                        top-id-bound-var-name
-                                                                                                                                                                        anon
-                                                                                                                                                                        diff-marks
-                                                                                                                                                                        same-marks?
-                                                                                                                                                                        join-subst
-                                                                                                                                                                        join-marks
-                                                                                                                                                                        join-wraps
-                                                                                                                                                                        smart-append
-                                                                                                                                                                        resolved-id-var-name
-                                                                                                                                                                        id->resolved-id
-                                                                                                                                                                        make-resolved-id
-                                                                                                                                                                        make-binding-wrap
-                                                                                                                                                                        store-import-binding
-                                                                                                                                                                        lookup-import-binding-name
-                                                                                                                                                                        extend-ribcage-subst!
-                                                                                                                                                                        extend-ribcage-barrier-help!
-                                                                                                                                                                        extend-ribcage-barrier!
-                                                                                                                                                                        import-extend-ribcage!
-                                                                                                                                                                        extend-ribcage!
-                                                                                                                                                                        make-empty-ribcage
-                                                                                                                                                                        barrier-marker
-                                                                                                                                                                        new-mark
-                                                                                                                                                                        anti-mark
-                                                                                                                                                                        the-anti-mark
-                                                                                                                                                                        set-env-wrap!
-                                                                                                                                                                        set-env-top-ribcage!
-                                                                                                                                                                        env-wrap
-                                                                                                                                                                        env-top-ribcage
-                                                                                                                                                                        env?
-                                                                                                                                                                        make-env
-                                                                                                                                                                        set-import-interface-new-marks!
-                                                                                                                                                                        set-import-interface-interface!
-                                                                                                                                                                        import-interface-new-marks
-                                                                                                                                                                        import-interface-interface
-                                                                                                                                                                        import-interface?
-                                                                                                                                                                        make-import-interface
-                                                                                                                                                                        set-top-ribcage-mutable?!
-                                                                                                                                                                        set-top-ribcage-key!
-                                                                                                                                                                        top-ribcage-mutable?
-                                                                                                                                                                        top-ribcage-key
-                                                                                                                                                                        top-ribcage?
-                                                                                                                                                                        make-top-ribcage
-                                                                                                                                                                        set-ribcage-labels!
-                                                                                                                                                                        set-ribcage-marks!
-                                                                                                                                                                        set-ribcage-symnames!
-                                                                                                                                                                        ribcage-labels
-                                                                                                                                                                        ribcage-marks
-                                                                                                                                                                        ribcage-symnames
-                                                                                                                                                                        ribcage?
-                                                                                                                                                                        make-ribcage
-                                                                                                                                                                        gen-labels
-                                                                                                                                                                        label?
-                                                                                                                                                                        gen-label
-                                                                                                                                                                        set-indirect-label!
-                                                                                                                                                                        get-indirect-label
-                                                                                                                                                                        indirect-label?
-                                                                                                                                                                        gen-indirect-label
-                                                                                                                                                                        anon
-                                                                                                                                                                        only-top-marked?
-                                                                                                                                                                        top-marked?
-                                                                                                                                                                        top-wrap
-                                                                                                                                                                        empty-wrap
-                                                                                                                                                                        wrap-subst
-                                                                                                                                                                        wrap-marks
-                                                                                                                                                                        make-wrap
-                                                                                                                                                                        id-sym-name&marks
-                                                                                                                                                                        id-subst
-                                                                                                                                                                        id-marks
-                                                                                                                                                                        id-sym-name
-                                                                                                                                                                        id?
-                                                                                                                                                                        nonsymbol-id?
-                                                                                                                                                                        global-extend
-                                                                                                                                                                        defer-or-eval-transformer
-                                                                                                                                                                        make-transformer-binding
-                                                                                                                                                                        lookup
-                                                                                                                                                                        lookup*
-                                                                                                                                                                        displaced-lexical-error
-                                                                                                                                                                        displaced-lexical?
-                                                                                                                                                                        extend-var-env*
-                                                                                                                                                                        extend-env*
-                                                                                                                                                                        extend-env
-                                                                                                                                                                        null-env
-                                                                                                                                                                        binding?
-                                                                                                                                                                        set-binding-value!
-                                                                                                                                                                        set-binding-type!
-                                                                                                                                                                        binding-value
-                                                                                                                                                                        binding-type
-                                                                                                                                                                        make-binding
-                                                                                                                                                                        sanitize-binding
-                                                                                                                                                                        arg-check
-                                                                                                                                                                        no-source
-                                                                                                                                                                        unannotate
-                                                                                                                                                                        self-evaluating?
-                                                                                                                                                                        lexical-var?
-                                                                                                                                                                        build-lexical-var
-                                                                                                                                                                        build-top-module
-                                                                                                                                                                        build-body
-                                                                                                                                                                        build-letrec
-                                                                                                                                                                        build-sequence
-                                                                                                                                                                        build-data
-                                                                                                                                                                        build-primref
-                                                                                                                                                                        built-lambda?
-                                                                                                                                                                        build-lambda
-                                                                                                                                                                        build-revisit-only
-                                                                                                                                                                        build-visit-only
-                                                                                                                                                                        build-cte-install
-                                                                                                                                                                        build-global-definition
-                                                                                                                                                                        build-global-assignment
-                                                                                                                                                                        build-global-reference
-                                                                                                                                                                        build-lexical-assignment
-                                                                                                                                                                        build-lexical-reference
-                                                                                                                                                                        build-conditional
-                                                                                                                                                                        build-application
-                                                                                                                                                                        generate-id
-                                                                                                                                                                        put-import-binding
-                                                                                                                                                                        get-import-binding
-                                                                                                                                                                        read-only-binding?
-                                                                                                                                                                        put-global-definition-hook
-                                                                                                                                                                        get-global-definition-hook
-                                                                                                                                                                        put-cte-hook
-                                                                                                                                                                        gensym-hook
-                                                                                                                                                                        error-hook
-                                                                                                                                                                        define-top-level-value-hook
-                                                                                                                                                                        local-eval-hook
-                                                                                                                                                                        top-level-eval-hook
-                                                                                                                                                                        annotation?
-                                                                                                                                                                        set-syntax-object-wrap!
-                                                                                                                                                                        set-syntax-object-expression!
-                                                                                                                                                                        syntax-object-wrap
-                                                                                                                                                                        syntax-object-expression
-                                                                                                                                                                        syntax-object?
-                                                                                                                                                                        make-syntax-object
-                                                                                                                                                                        noexpand
-                                                                                                                                                                        let-values
-                                                                                                                                                                        define-structure
-                                                                                                                                                                        unless
-                                                                                                                                                                        when)
-                                                                                                                                                                       ((top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        ("m" top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        ("m" top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top)
-                                                                                                                                                                        (top))
-                                                                                                                                                                       ("i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"
-                                                                                                                                                                        "i"))
-                                                                                                                                                                     #(top-ribcage
-                                                                                                                                                                       *top*
-                                                                                                                                                                       #t)))
-                                                                                                                                                                g930
-                                                                                                                                                                g929)])
-                                                                                                                                                           g919
-                                                                                                                                                           g927))))))
-                                                                                                                                               (#%cons
-                                                                                                                                                 (#%list
-                                                                                                                                                   '#(syntax-object
-                                                                                                                                                      $import
-                                                                                                                                                      ((top)
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(d
-                                                                                                                                                            tmid
-                                                                                                                                                            tmp
-                                                                                                                                                            other-id)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          ()
-                                                                                                                                                          ()
-                                                                                                                                                          ())
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(mid
-                                                                                                                                                            d
-                                                                                                                                                            exports)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(m
-                                                                                                                                                            new-id
-                                                                                                                                                            old-id)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(orig
-                                                                                                                                                            import-only?)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          ()
-                                                                                                                                                          ()
-                                                                                                                                                          ())
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(m
-                                                                                                                                                            exports?)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          (modspec*
-                                                                                                                                                            modspec
-                                                                                                                                                            gen-mid
-                                                                                                                                                            prefix-drop
-                                                                                                                                                            prefix-add
-                                                                                                                                                            difference)
-                                                                                                                                                          ((top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top)
-                                                                                                                                                            (top))
-                                                                                                                                                          ("i" "i"
-                                                                                                                                                               "i"
-                                                                                                                                                               "i"
-                                                                                                                                                               "i"
-                                                                                                                                                               "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(r)
-                                                                                                                                                          #((top))
-                                                                                                                                                          #("i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          ()
-                                                                                                                                                          ()
-                                                                                                                                                          ())
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          #(orig
-                                                                                                                                                            import-only?)
-                                                                                                                                                          #((top)
-                                                                                                                                                            (top))
-                                                                                                                                                          #("i"
-                                                                                                                                                            "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          ($import-help
-                                                                                                                                                            $module-exports)
-                                                                                                                                                          ((top)
-                                                                                                                                                            (top))
-                                                                                                                                                          ("i" "i"))
-                                                                                                                                                        #(ribcage
-                                                                                                                                                          (lambda-var-list
-                                                                                                                                                           gen-var
-                                                                                                                                                           strip
-                                                                                                                                                           strip*
-                                                                                                                                                           strip-annotation
-                                                                                                                                                           ellipsis?
-                                                                                                                                                           chi-void
-                                                                                                                                                           chi-local-syntax
-                                                                                                                                                           chi-lambda-clause
-                                                                                                                                                           parse-begin
-                                                                                                                                                           parse-alias
-                                                                                                                                                           parse-eval-when
-                                                                                                                                                           parse-meta
-                                                                                                                                                           parse-define-syntax
-                                                                                                                                                           parse-define
-                                                                                                                                                           parse-import
-                                                                                                                                                           parse-module
-                                                                                                                                                           do-import!
-                                                                                                                                                           lookup-import-label
-                                                                                                                                                           import-mark-delta
-                                                                                                                                                           chi-internal
-                                                                                                                                                           chi-body
-                                                                                                                                                           chi-macro
-                                                                                                                                                           chi-set!
-                                                                                                                                                           chi-application
-                                                                                                                                                           chi-expr
-                                                                                                                                                           chi
-                                                                                                                                                           chi-sequence
-                                                                                                                                                           chi-meta-frob
-                                                                                                                                                           chi-frobs
-                                                                                                                                                           ct-eval/residualize3
-                                                                                                                                                           ct-eval/residualize2
-                                                                                                                                                           rt-eval/residualize
-                                                                                                                                                           initial-mode-set
-                                                                                                                                                           update-mode-set
-                                                                                                                                                           do-top-import
-                                                                                                                                                           vfor-each
-                                                                                                                                                           vmap
-                                                                                                                                                           chi-external
-                                                                                                                                                           check-defined-ids
-                                                                                                                                                           check-module-exports
-                                                                                                                                                           id-set-diff
-                                                                                                                                                           chi-top-module
-                                                                                                                                                           set-frob-meta?!
-                                                                                                                                                           set-frob-e!
-                                                                                                                                                           frob-meta?
-                                                                                                                                                           frob-e
-                                                                                                                                                           frob?
-                                                                                                                                                           make-frob
-                                                                                                                                                           create-module-binding
-                                                                                                                                                           set-module-binding-exported!
-                                                                                                                                                           set-module-binding-val!
-                                                                                                                                                           set-module-binding-imps!
-                                                                                                                                                           set-module-binding-label!
-                                                                                                                                                           set-module-binding-id!
-                                                                                                                                                           set-module-binding-type!
-                                                                                                                                                           module-binding-exported
-                                                                                                                                                           module-binding-val
-                                                                                                                                                           module-binding-imps
-                                                                                                                                                           module-binding-label
-                                                                                                                                                           module-binding-id
-                                                                                                                                                           module-binding-type
-                                                                                                                                                           module-binding?
-                                                                                                                                                           make-module-binding
-                                                                                                                                                           make-resolved-interface
-                                                                                                                                                           make-unresolved-interface
-                                                                                                                                                           set-interface-token!
-                                                                                                                                                           set-interface-exports!
-                                                                                                                                                           set-interface-marks!
-                                                                                                                                                           interface-token
-                                                                                                                                                           interface-exports
-                                                                                                                                                           interface-marks
-                                                                                                                                                           interface?
-                                                                                                                                                           make-interface
-                                                                                                                                                           flatten-exports
-                                                                                                                                                           chi-top
-                                                                                                                                                           chi-top-sequence
-                                                                                                                                                           chi-top*
-                                                                                                                                                           syntax-type
-                                                                                                                                                           chi-when-list
-                                                                                                                                                           source-wrap
-                                                                                                                                                           wrap
-                                                                                                                                                           bound-id-member?
-                                                                                                                                                           invalid-ids-error
-                                                                                                                                                           distinct-bound-ids?
-                                                                                                                                                           valid-bound-ids?
-                                                                                                                                                           bound-id=?
-                                                                                                                                                           help-bound-id=?
-                                                                                                                                                           literal-id=?
-                                                                                                                                                           free-id=?
-                                                                                                                                                           id-var-name
-                                                                                                                                                           id-var-name-loc
-                                                                                                                                                           id-var-name&marks
-                                                                                                                                                           id-var-name-loc&marks
-                                                                                                                                                           top-id-free-var-name
-                                                                                                                                                           top-id-bound-var-name
-                                                                                                                                                           anon
-                                                                                                                                                           diff-marks
-                                                                                                                                                           same-marks?
-                                                                                                                                                           join-subst
-                                                                                                                                                           join-marks
-                                                                                                                                                           join-wraps
-                                                                                                                                                           smart-append
-                                                                                                                                                           resolved-id-var-name
-                                                                                                                                                           id->resolved-id
-                                                                                                                                                           make-resolved-id
-                                                                                                                                                           make-binding-wrap
-                                                                                                                                                           store-import-binding
-                                                                                                                                                           lookup-import-binding-name
-                                                                                                                                                           extend-ribcage-subst!
-                                                                                                                                                           extend-ribcage-barrier-help!
-                                                                                                                                                           extend-ribcage-barrier!
-                                                                                                                                                           import-extend-ribcage!
-                                                                                                                                                           extend-ribcage!
-                                                                                                                                                           make-empty-ribcage
-                                                                                                                                                           barrier-marker
-                                                                                                                                                           new-mark
-                                                                                                                                                           anti-mark
-                                                                                                                                                           the-anti-mark
-                                                                                                                                                           set-env-wrap!
-                                                                                                                                                           set-env-top-ribcage!
-                                                                                                                                                           env-wrap
-                                                                                                                                                           env-top-ribcage
-                                                                                                                                                           env?
-                                                                                                                                                           make-env
-                                                                                                                                                           set-import-interface-new-marks!
-                                                                                                                                                           set-import-interface-interface!
-                                                                                                                                                           import-interface-new-marks
-                                                                                                                                                           import-interface-interface
-                                                                                                                                                           import-interface?
-                                                                                                                                                           make-import-interface
-                                                                                                                                                           set-top-ribcage-mutable?!
-                                                                                                                                                           set-top-ribcage-key!
-                                                                                                                                                           top-ribcage-mutable?
-                                                                                                                                                           top-ribcage-key
-                                                                                                                                                           top-ribcage?
-                                                                                                                                                           make-top-ribcage
-                                                                                                                                                           set-ribcage-labels!
-                                                                                                                                                           set-ribcage-marks!
-                                                                                                                                                           set-ribcage-symnames!
-                                                                                                                                                           ribcage-labels
-                                                                                                                                                           ribcage-marks
-                                                                                                                                                           ribcage-symnames
-                                                                                                                                                           ribcage?
-                                                                                                                                                           make-ribcage
-                                                                                                                                                           gen-labels
-                                                                                                                                                           label?
-                                                                                                                                                           gen-label
-                                                                                                                                                           set-indirect-label!
-                                                                                                                                                           get-indirect-label
-                                                                                                                                                           indirect-label?
-                                                                                                                                                           gen-indirect-label
-                                                                                                                                                           anon
-                                                                                                                                                           only-top-marked?
-                                                                                                                                                           top-marked?
-                                                                                                                                                           top-wrap
-                                                                                                                                                           empty-wrap
-                                                                                                                                                           wrap-subst
-                                                                                                                                                           wrap-marks
-                                                                                                                                                           make-wrap
-                                                                                                                                                           id-sym-name&marks
-                                                                                                                                                           id-subst
-                                                                                                                                                           id-marks
-                                                                                                                                                           id-sym-name
-                                                                                                                                                           id?
-                                                                                                                                                           nonsymbol-id?
-                                                                                                                                                           global-extend
-                                                                                                                                                           defer-or-eval-transformer
-                                                                                                                                                           make-transformer-binding
-                                                                                                                                                           lookup
-                                                                                                                                                           lookup*
-                                                                                                                                                           displaced-lexical-error
-                                                                                                                                                           displaced-lexical?
-                                                                                                                                                           extend-var-env*
-                                                                                                                                                           extend-env*
-                                                                                                                                                           extend-env
-                                                                                                                                                           null-env
-                                                                                                                                                           binding?
-                                                                                                                                                           set-binding-value!
-                                                                                                                                                           set-binding-type!
-                                                                                                                                                           binding-value
-                                                                                                                                                           binding-type
-                                                                                                                                                           make-binding
-                                                                                                                                                           sanitize-binding
-                                                                                                                                                           arg-check
-                                                                                                                                                           no-source
-                                                                                                                                                           unannotate
-                                                                                                                                                           self-evaluating?
-                                                                                                                                                           lexical-var?
-                                                                                                                                                           build-lexical-var
-                                                                                                                                                           build-top-module
-                                                                                                                                                           build-body
-                                                                                                                                                           build-letrec
-                                                                                                                                                           build-sequence
-                                                                                                                                                           build-data
-                                                                                                                                                           build-primref
-                                                                                                                                                           built-lambda?
-                                                                                                                                                           build-lambda
-                                                                                                                                                           build-revisit-only
-                                                                                                                                                           build-visit-only
-                                                                                                                                                           build-cte-install
-                                                                                                                                                           build-global-definition
-                                                                                                                                                           build-global-assignment
-                                                                                                                                                           build-global-reference
-                                                                                                                                                           build-lexical-assignment
-                                                                                                                                                           build-lexical-reference
-                                                                                                                                                           build-conditional
-                                                                                                                                                           build-application
-                                                                                                                                                           generate-id
-                                                                                                                                                           put-import-binding
-                                                                                                                                                           get-import-binding
-                                                                                                                                                           read-only-binding?
-                                                                                                                                                           put-global-definition-hook
-                                                                                                                                                           get-global-definition-hook
-                                                                                                                                                           put-cte-hook
-                                                                                                                                                           gensym-hook
-                                                                                                                                                           error-hook
-                                                                                                                                                           define-top-level-value-hook
-                                                                                                                                                           local-eval-hook
-                                                                                                                                                           top-level-eval-hook
-                                                                                                                                                           annotation?
-                                                                                                                                                           set-syntax-object-wrap!
-                                                                                                                                                           set-syntax-object-expression!
-                                                                                                                                                           syntax-object-wrap
-                                                                                                                                                           syntax-object-expression
-                                                                                                                                                           syntax-object?
-                                                                                                                                                           make-syntax-object
-                                                                                                                                                           noexpand
-                                                                                                                                                           let-values
-                                                                                                                                                           define-structure
-                                                                                                                                                           unless
-                                                                                                                                                           when)
-                                                                                                                                                          ((top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           ("m" top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           ("m" top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top)
-                                                                                                                                                           (top))
-                                                                                                                                                          ("i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"))
-                                                                                                                                                        #(top-ribcage
-                                                                                                                                                          *top*
-                                                                                                                                                          #t)))
-                                                                                                                                                   g847
-                                                                                                                                                   g848
-                                                                                                                                                   g926)
-                                                                                                                                                 (#%map
-                                                                                                                                                   (case-lambda
-                                                                                                                                                     [(g931
-                                                                                                                                                       g932)
-                                                                                                                                                      (#%list
-                                                                                                                                                        '#(syntax-object
-                                                                                                                                                           alias
-                                                                                                                                                           ((top)
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(d
-                                                                                                                                                                 tmid
-                                                                                                                                                                 tmp
-                                                                                                                                                                 other-id)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(mid
-                                                                                                                                                                 d
-                                                                                                                                                                 exports)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(m
-                                                                                                                                                                 new-id
-                                                                                                                                                                 old-id)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(orig
-                                                                                                                                                                 import-only?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(m
-                                                                                                                                                                 exports?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               (modspec*
-                                                                                                                                                                 modspec
-                                                                                                                                                                 gen-mid
-                                                                                                                                                                 prefix-drop
-                                                                                                                                                                 prefix-add
-                                                                                                                                                                 difference)
-                                                                                                                                                               ((top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               ("i" "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"
-                                                                                                                                                                    "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(r)
-                                                                                                                                                               #((top))
-                                                                                                                                                               #("i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ()
-                                                                                                                                                               ()
-                                                                                                                                                               ())
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               #(orig
-                                                                                                                                                                 import-only?)
-                                                                                                                                                               #((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               #("i"
-                                                                                                                                                                 "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               ($import-help
-                                                                                                                                                                 $module-exports)
-                                                                                                                                                               ((top)
-                                                                                                                                                                 (top))
-                                                                                                                                                               ("i" "i"))
-                                                                                                                                                             #(ribcage
-                                                                                                                                                               (lambda-var-list
-                                                                                                                                                                gen-var
-                                                                                                                                                                strip
-                                                                                                                                                                strip*
-                                                                                                                                                                strip-annotation
-                                                                                                                                                                ellipsis?
-                                                                                                                                                                chi-void
-                                                                                                                                                                chi-local-syntax
-                                                                                                                                                                chi-lambda-clause
-                                                                                                                                                                parse-begin
-                                                                                                                                                                parse-alias
-                                                                                                                                                                parse-eval-when
-                                                                                                                                                                parse-meta
-                                                                                                                                                                parse-define-syntax
-                                                                                                                                                                parse-define
-                                                                                                                                                                parse-import
-                                                                                                                                                                parse-module
-                                                                                                                                                                do-import!
-                                                                                                                                                                lookup-import-label
-                                                                                                                                                                import-mark-delta
-                                                                                                                                                                chi-internal
-                                                                                                                                                                chi-body
-                                                                                                                                                                chi-macro
-                                                                                                                                                                chi-set!
-                                                                                                                                                                chi-application
-                                                                                                                                                                chi-expr
-                                                                                                                                                                chi
-                                                                                                                                                                chi-sequence
-                                                                                                                                                                chi-meta-frob
-                                                                                                                                                                chi-frobs
-                                                                                                                                                                ct-eval/residualize3
-                                                                                                                                                                ct-eval/residualize2
-                                                                                                                                                                rt-eval/residualize
-                                                                                                                                                                initial-mode-set
-                                                                                                                                                                update-mode-set
-                                                                                                                                                                do-top-import
-                                                                                                                                                                vfor-each
-                                                                                                                                                                vmap
-                                                                                                                                                                chi-external
-                                                                                                                                                                check-defined-ids
-                                                                                                                                                                check-module-exports
-                                                                                                                                                                id-set-diff
-                                                                                                                                                                chi-top-module
-                                                                                                                                                                set-frob-meta?!
-                                                                                                                                                                set-frob-e!
-                                                                                                                                                                frob-meta?
-                                                                                                                                                                frob-e
-                                                                                                                                                                frob?
-                                                                                                                                                                make-frob
-                                                                                                                                                                create-module-binding
-                                                                                                                                                                set-module-binding-exported!
-                                                                                                                                                                set-module-binding-val!
-                                                                                                                                                                set-module-binding-imps!
-                                                                                                                                                                set-module-binding-label!
-                                                                                                                                                                set-module-binding-id!
-                                                                                                                                                                set-module-binding-type!
-                                                                                                                                                                module-binding-exported
-                                                                                                                                                                module-binding-val
-                                                                                                                                                                module-binding-imps
-                                                                                                                                                                module-binding-label
-                                                                                                                                                                module-binding-id
-                                                                                                                                                                module-binding-type
-                                                                                                                                                                module-binding?
-                                                                                                                                                                make-module-binding
-                                                                                                                                                                make-resolved-interface
-                                                                                                                                                                make-unresolved-interface
-                                                                                                                                                                set-interface-token!
-                                                                                                                                                                set-interface-exports!
-                                                                                                                                                                set-interface-marks!
-                                                                                                                                                                interface-token
-                                                                                                                                                                interface-exports
-                                                                                                                                                                interface-marks
-                                                                                                                                                                interface?
-                                                                                                                                                                make-interface
-                                                                                                                                                                flatten-exports
-                                                                                                                                                                chi-top
-                                                                                                                                                                chi-top-sequence
-                                                                                                                                                                chi-top*
-                                                                                                                                                                syntax-type
-                                                                                                                                                                chi-when-list
-                                                                                                                                                                source-wrap
-                                                                                                                                                                wrap
-                                                                                                                                                                bound-id-member?
-                                                                                                                                                                invalid-ids-error
-                                                                                                                                                                distinct-bound-ids?
-                                                                                                                                                                valid-bound-ids?
-                                                                                                                                                                bound-id=?
-                                                                                                                                                                help-bound-id=?
-                                                                                                                                                                literal-id=?
-                                                                                                                                                                free-id=?
-                                                                                                                                                                id-var-name
-                                                                                                                                                                id-var-name-loc
-                                                                                                                                                                id-var-name&marks
-                                                                                                                                                                id-var-name-loc&marks
-                                                                                                                                                                top-id-free-var-name
-                                                                                                                                                                top-id-bound-var-name
-                                                                                                                                                                anon
-                                                                                                                                                                diff-marks
-                                                                                                                                                                same-marks?
-                                                                                                                                                                join-subst
-                                                                                                                                                                join-marks
-                                                                                                                                                                join-wraps
-                                                                                                                                                                smart-append
-                                                                                                                                                                resolved-id-var-name
-                                                                                                                                                                id->resolved-id
-                                                                                                                                                                make-resolved-id
-                                                                                                                                                                make-binding-wrap
-                                                                                                                                                                store-import-binding
-                                                                                                                                                                lookup-import-binding-name
-                                                                                                                                                                extend-ribcage-subst!
-                                                                                                                                                                extend-ribcage-barrier-help!
-                                                                                                                                                                extend-ribcage-barrier!
-                                                                                                                                                                import-extend-ribcage!
-                                                                                                                                                                extend-ribcage!
-                                                                                                                                                                make-empty-ribcage
-                                                                                                                                                                barrier-marker
-                                                                                                                                                                new-mark
-                                                                                                                                                                anti-mark
-                                                                                                                                                                the-anti-mark
-                                                                                                                                                                set-env-wrap!
-                                                                                                                                                                set-env-top-ribcage!
-                                                                                                                                                                env-wrap
-                                                                                                                                                                env-top-ribcage
-                                                                                                                                                                env?
-                                                                                                                                                                make-env
-                                                                                                                                                                set-import-interface-new-marks!
-                                                                                                                                                                set-import-interface-interface!
-                                                                                                                                                                import-interface-new-marks
-                                                                                                                                                                import-interface-interface
-                                                                                                                                                                import-interface?
-                                                                                                                                                                make-import-interface
-                                                                                                                                                                set-top-ribcage-mutable?!
-                                                                                                                                                                set-top-ribcage-key!
-                                                                                                                                                                top-ribcage-mutable?
-                                                                                                                                                                top-ribcage-key
-                                                                                                                                                                top-ribcage?
-                                                                                                                                                                make-top-ribcage
-                                                                                                                                                                set-ribcage-labels!
-                                                                                                                                                                set-ribcage-marks!
-                                                                                                                                                                set-ribcage-symnames!
-                                                                                                                                                                ribcage-labels
-                                                                                                                                                                ribcage-marks
-                                                                                                                                                                ribcage-symnames
-                                                                                                                                                                ribcage?
-                                                                                                                                                                make-ribcage
-                                                                                                                                                                gen-labels
-                                                                                                                                                                label?
-                                                                                                                                                                gen-label
-                                                                                                                                                                set-indirect-label!
-                                                                                                                                                                get-indirect-label
-                                                                                                                                                                indirect-label?
-                                                                                                                                                                gen-indirect-label
-                                                                                                                                                                anon
-                                                                                                                                                                only-top-marked?
-                                                                                                                                                                top-marked?
-                                                                                                                                                                top-wrap
-                                                                                                                                                                empty-wrap
-                                                                                                                                                                wrap-subst
-                                                                                                                                                                wrap-marks
-                                                                                                                                                                make-wrap
-                                                                                                                                                                id-sym-name&marks
-                                                                                                                                                                id-subst
-                                                                                                                                                                id-marks
-                                                                                                                                                                id-sym-name
-                                                                                                                                                                id?
-                                                                                                                                                                nonsymbol-id?
-                                                                                                                                                                global-extend
-                                                                                                                                                                defer-or-eval-transformer
-                                                                                                                                                                make-transformer-binding
-                                                                                                                                                                lookup
-                                                                                                                                                                lookup*
-                                                                                                                                                                displaced-lexical-error
-                                                                                                                                                                displaced-lexical?
-                                                                                                                                                                extend-var-env*
-                                                                                                                                                                extend-env*
-                                                                                                                                                                extend-env
-                                                                                                                                                                null-env
-                                                                                                                                                                binding?
-                                                                                                                                                                set-binding-value!
-                                                                                                                                                                set-binding-type!
-                                                                                                                                                                binding-value
-                                                                                                                                                                binding-type
-                                                                                                                                                                make-binding
-                                                                                                                                                                sanitize-binding
-                                                                                                                                                                arg-check
-                                                                                                                                                                no-source
-                                                                                                                                                                unannotate
-                                                                                                                                                                self-evaluating?
-                                                                                                                                                                lexical-var?
-                                                                                                                                                                build-lexical-var
-                                                                                                                                                                build-top-module
-                                                                                                                                                                build-body
-                                                                                                                                                                build-letrec
-                                                                                                                                                                build-sequence
-                                                                                                                                                                build-data
-                                                                                                                                                                build-primref
-                                                                                                                                                                built-lambda?
-                                                                                                                                                                build-lambda
-                                                                                                                                                                build-revisit-only
-                                                                                                                                                                build-visit-only
-                                                                                                                                                                build-cte-install
-                                                                                                                                                                build-global-definition
-                                                                                                                                                                build-global-assignment
-                                                                                                                                                                build-global-reference
-                                                                                                                                                                build-lexical-assignment
-                                                                                                                                                                build-lexical-reference
-                                                                                                                                                                build-conditional
-                                                                                                                                                                build-application
-                                                                                                                                                                generate-id
-                                                                                                                                                                put-import-binding
-                                                                                                                                                                get-import-binding
-                                                                                                                                                                read-only-binding?
-                                                                                                                                                                put-global-definition-hook
-                                                                                                                                                                get-global-definition-hook
-                                                                                                                                                                put-cte-hook
-                                                                                                                                                                gensym-hook
-                                                                                                                                                                error-hook
-                                                                                                                                                                define-top-level-value-hook
-                                                                                                                                                                local-eval-hook
-                                                                                                                                                                top-level-eval-hook
-                                                                                                                                                                annotation?
-                                                                                                                                                                set-syntax-object-wrap!
-                                                                                                                                                                set-syntax-object-expression!
-                                                                                                                                                                syntax-object-wrap
-                                                                                                                                                                syntax-object-expression
-                                                                                                                                                                syntax-object?
-                                                                                                                                                                make-syntax-object
-                                                                                                                                                                noexpand
-                                                                                                                                                                let-values
-                                                                                                                                                                define-structure
-                                                                                                                                                                unless
-                                                                                                                                                                when)
-                                                                                                                                                               ((top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                ("m" top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                ("m" top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top)
-                                                                                                                                                                (top))
-                                                                                                                                                               ("i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"
-                                                                                                                                                                "i"))
-                                                                                                                                                             #(top-ribcage
-                                                                                                                                                               *top*
-                                                                                                                                                               #t)))
-                                                                                                                                                        g932
-                                                                                                                                                        g931)])
-                                                                                                                                                   g927
-                                                                                                                                                   g918)))))))
-                                                                                                                                     (#%list
-                                                                                                                                       '#(syntax-object
-                                                                                                                                          $import
-                                                                                                                                          ((top)
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(d
-                                                                                                                                                tmid
-                                                                                                                                                tmp
-                                                                                                                                                other-id)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(mid
-                                                                                                                                                d
-                                                                                                                                                exports)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(m
-                                                                                                                                                new-id
-                                                                                                                                                old-id)
-                                                                                                                                              #((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(m
-                                                                                                                                                exports?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (modspec*
-                                                                                                                                                modspec
-                                                                                                                                                gen-mid
-                                                                                                                                                prefix-drop
-                                                                                                                                                prefix-add
-                                                                                                                                                difference)
-                                                                                                                                              ((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(r)
-                                                                                                                                              #((top))
-                                                                                                                                              #("i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ($import-help
-                                                                                                                                                $module-exports)
-                                                                                                                                              ((top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (lambda-var-list
-                                                                                                                                               gen-var
-                                                                                                                                               strip
-                                                                                                                                               strip*
-                                                                                                                                               strip-annotation
-                                                                                                                                               ellipsis?
-                                                                                                                                               chi-void
-                                                                                                                                               chi-local-syntax
-                                                                                                                                               chi-lambda-clause
-                                                                                                                                               parse-begin
-                                                                                                                                               parse-alias
-                                                                                                                                               parse-eval-when
-                                                                                                                                               parse-meta
-                                                                                                                                               parse-define-syntax
-                                                                                                                                               parse-define
-                                                                                                                                               parse-import
-                                                                                                                                               parse-module
-                                                                                                                                               do-import!
-                                                                                                                                               lookup-import-label
-                                                                                                                                               import-mark-delta
-                                                                                                                                               chi-internal
-                                                                                                                                               chi-body
-                                                                                                                                               chi-macro
-                                                                                                                                               chi-set!
-                                                                                                                                               chi-application
-                                                                                                                                               chi-expr
-                                                                                                                                               chi
-                                                                                                                                               chi-sequence
-                                                                                                                                               chi-meta-frob
-                                                                                                                                               chi-frobs
-                                                                                                                                               ct-eval/residualize3
-                                                                                                                                               ct-eval/residualize2
-                                                                                                                                               rt-eval/residualize
-                                                                                                                                               initial-mode-set
-                                                                                                                                               update-mode-set
-                                                                                                                                               do-top-import
-                                                                                                                                               vfor-each
-                                                                                                                                               vmap
-                                                                                                                                               chi-external
-                                                                                                                                               check-defined-ids
-                                                                                                                                               check-module-exports
-                                                                                                                                               id-set-diff
-                                                                                                                                               chi-top-module
-                                                                                                                                               set-frob-meta?!
-                                                                                                                                               set-frob-e!
-                                                                                                                                               frob-meta?
-                                                                                                                                               frob-e
-                                                                                                                                               frob?
-                                                                                                                                               make-frob
-                                                                                                                                               create-module-binding
-                                                                                                                                               set-module-binding-exported!
-                                                                                                                                               set-module-binding-val!
-                                                                                                                                               set-module-binding-imps!
-                                                                                                                                               set-module-binding-label!
-                                                                                                                                               set-module-binding-id!
-                                                                                                                                               set-module-binding-type!
-                                                                                                                                               module-binding-exported
-                                                                                                                                               module-binding-val
-                                                                                                                                               module-binding-imps
-                                                                                                                                               module-binding-label
-                                                                                                                                               module-binding-id
-                                                                                                                                               module-binding-type
-                                                                                                                                               module-binding?
-                                                                                                                                               make-module-binding
-                                                                                                                                               make-resolved-interface
-                                                                                                                                               make-unresolved-interface
-                                                                                                                                               set-interface-token!
-                                                                                                                                               set-interface-exports!
-                                                                                                                                               set-interface-marks!
-                                                                                                                                               interface-token
-                                                                                                                                               interface-exports
-                                                                                                                                               interface-marks
-                                                                                                                                               interface?
-                                                                                                                                               make-interface
-                                                                                                                                               flatten-exports
-                                                                                                                                               chi-top
-                                                                                                                                               chi-top-sequence
-                                                                                                                                               chi-top*
-                                                                                                                                               syntax-type
-                                                                                                                                               chi-when-list
-                                                                                                                                               source-wrap
-                                                                                                                                               wrap
-                                                                                                                                               bound-id-member?
-                                                                                                                                               invalid-ids-error
-                                                                                                                                               distinct-bound-ids?
-                                                                                                                                               valid-bound-ids?
-                                                                                                                                               bound-id=?
-                                                                                                                                               help-bound-id=?
-                                                                                                                                               literal-id=?
-                                                                                                                                               free-id=?
-                                                                                                                                               id-var-name
-                                                                                                                                               id-var-name-loc
-                                                                                                                                               id-var-name&marks
-                                                                                                                                               id-var-name-loc&marks
-                                                                                                                                               top-id-free-var-name
-                                                                                                                                               top-id-bound-var-name
-                                                                                                                                               anon
-                                                                                                                                               diff-marks
-                                                                                                                                               same-marks?
-                                                                                                                                               join-subst
-                                                                                                                                               join-marks
-                                                                                                                                               join-wraps
-                                                                                                                                               smart-append
-                                                                                                                                               resolved-id-var-name
-                                                                                                                                               id->resolved-id
-                                                                                                                                               make-resolved-id
-                                                                                                                                               make-binding-wrap
-                                                                                                                                               store-import-binding
-                                                                                                                                               lookup-import-binding-name
-                                                                                                                                               extend-ribcage-subst!
-                                                                                                                                               extend-ribcage-barrier-help!
-                                                                                                                                               extend-ribcage-barrier!
-                                                                                                                                               import-extend-ribcage!
-                                                                                                                                               extend-ribcage!
-                                                                                                                                               make-empty-ribcage
-                                                                                                                                               barrier-marker
-                                                                                                                                               new-mark
-                                                                                                                                               anti-mark
-                                                                                                                                               the-anti-mark
-                                                                                                                                               set-env-wrap!
-                                                                                                                                               set-env-top-ribcage!
-                                                                                                                                               env-wrap
-                                                                                                                                               env-top-ribcage
-                                                                                                                                               env?
-                                                                                                                                               make-env
-                                                                                                                                               set-import-interface-new-marks!
-                                                                                                                                               set-import-interface-interface!
-                                                                                                                                               import-interface-new-marks
-                                                                                                                                               import-interface-interface
-                                                                                                                                               import-interface?
-                                                                                                                                               make-import-interface
-                                                                                                                                               set-top-ribcage-mutable?!
-                                                                                                                                               set-top-ribcage-key!
-                                                                                                                                               top-ribcage-mutable?
-                                                                                                                                               top-ribcage-key
-                                                                                                                                               top-ribcage?
-                                                                                                                                               make-top-ribcage
-                                                                                                                                               set-ribcage-labels!
-                                                                                                                                               set-ribcage-marks!
-                                                                                                                                               set-ribcage-symnames!
-                                                                                                                                               ribcage-labels
-                                                                                                                                               ribcage-marks
-                                                                                                                                               ribcage-symnames
-                                                                                                                                               ribcage?
-                                                                                                                                               make-ribcage
-                                                                                                                                               gen-labels
-                                                                                                                                               label?
-                                                                                                                                               gen-label
-                                                                                                                                               set-indirect-label!
-                                                                                                                                               get-indirect-label
-                                                                                                                                               indirect-label?
-                                                                                                                                               gen-indirect-label
-                                                                                                                                               anon
-                                                                                                                                               only-top-marked?
-                                                                                                                                               top-marked?
-                                                                                                                                               top-wrap
-                                                                                                                                               empty-wrap
-                                                                                                                                               wrap-subst
-                                                                                                                                               wrap-marks
-                                                                                                                                               make-wrap
-                                                                                                                                               id-sym-name&marks
-                                                                                                                                               id-subst
-                                                                                                                                               id-marks
-                                                                                                                                               id-sym-name
-                                                                                                                                               id?
-                                                                                                                                               nonsymbol-id?
-                                                                                                                                               global-extend
-                                                                                                                                               defer-or-eval-transformer
-                                                                                                                                               make-transformer-binding
-                                                                                                                                               lookup
-                                                                                                                                               lookup*
-                                                                                                                                               displaced-lexical-error
-                                                                                                                                               displaced-lexical?
-                                                                                                                                               extend-var-env*
-                                                                                                                                               extend-env*
-                                                                                                                                               extend-env
-                                                                                                                                               null-env
-                                                                                                                                               binding?
-                                                                                                                                               set-binding-value!
-                                                                                                                                               set-binding-type!
-                                                                                                                                               binding-value
-                                                                                                                                               binding-type
-                                                                                                                                               make-binding
-                                                                                                                                               sanitize-binding
-                                                                                                                                               arg-check
-                                                                                                                                               no-source
-                                                                                                                                               unannotate
-                                                                                                                                               self-evaluating?
-                                                                                                                                               lexical-var?
-                                                                                                                                               build-lexical-var
-                                                                                                                                               build-top-module
-                                                                                                                                               build-body
-                                                                                                                                               build-letrec
-                                                                                                                                               build-sequence
-                                                                                                                                               build-data
-                                                                                                                                               build-primref
-                                                                                                                                               built-lambda?
-                                                                                                                                               build-lambda
-                                                                                                                                               build-revisit-only
-                                                                                                                                               build-visit-only
-                                                                                                                                               build-cte-install
-                                                                                                                                               build-global-definition
-                                                                                                                                               build-global-assignment
-                                                                                                                                               build-global-reference
-                                                                                                                                               build-lexical-assignment
-                                                                                                                                               build-lexical-reference
-                                                                                                                                               build-conditional
-                                                                                                                                               build-application
-                                                                                                                                               generate-id
-                                                                                                                                               put-import-binding
-                                                                                                                                               get-import-binding
-                                                                                                                                               read-only-binding?
-                                                                                                                                               put-global-definition-hook
-                                                                                                                                               get-global-definition-hook
-                                                                                                                                               put-cte-hook
-                                                                                                                                               gensym-hook
-                                                                                                                                               error-hook
-                                                                                                                                               define-top-level-value-hook
-                                                                                                                                               local-eval-hook
-                                                                                                                                               top-level-eval-hook
-                                                                                                                                               annotation?
-                                                                                                                                               set-syntax-object-wrap!
-                                                                                                                                               set-syntax-object-expression!
-                                                                                                                                               syntax-object-wrap
-                                                                                                                                               syntax-object-expression
-                                                                                                                                               syntax-object?
-                                                                                                                                               make-syntax-object
-                                                                                                                                               noexpand
-                                                                                                                                               let-values
-                                                                                                                                               define-structure
-                                                                                                                                               unless
-                                                                                                                                               when)
-                                                                                                                                              ((top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top))
-                                                                                                                                              ("i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"))
-                                                                                                                                            #(top-ribcage
-                                                                                                                                              *top*
-                                                                                                                                              #t)))
-                                                                                                                                       g847
-                                                                                                                                       g848
-                                                                                                                                       g926))
-                                                                                                                                   (if g844
-                                                                                                                                       (#%append
-                                                                                                                                         g918
-                                                                                                                                         g928)
-                                                                                                                                       '#f))])
-                                                                                                                              g924)
-                                                                                                                            (#%syntax-error
-                                                                                                                              g923))])
-                                                                                                                      (#%$syntax-dispatch
-                                                                                                                        g923
-                                                                                                                        '(any any
-                                                                                                                              each-any
-                                                                                                                              each-any)))])
-                                                                                                                  ((top-level-value
-                                                                                                                     'list)
-                                                                                                                    g921
-                                                                                                                    (g815
-                                                                                                                      g920)
-                                                                                                                    ((top-level-value
-                                                                                                                       'generate-temporaries)
-                                                                                                                      g919)
-                                                                                                                    (g812
-                                                                                                                      g922
-                                                                                                                      g919)))]))])
-                                                                                                        g913)
-                                                                                                      ((case-lambda
-                                                                                                         [(g933)
-                                                                                                          (if (if g933
-                                                                                                                  (#%apply
-                                                                                                                    (case-lambda
-                                                                                                                      [(g934
-                                                                                                                        g935
-                                                                                                                        g936)
-                                                                                                                       (if ((top-level-value
-                                                                                                                              'andmap)
-                                                                                                                             (top-level-value
-                                                                                                                               'identifier?)
-                                                                                                                             g935)
-                                                                                                                           ((top-level-value
-                                                                                                                              'andmap)
-                                                                                                                             (top-level-value
-                                                                                                                               'identifier?)
-                                                                                                                             g936)
-                                                                                                                           '#f)])
-                                                                                                                    g933)
-                                                                                                                  '#f)
-                                                                                                              (#%apply
-                                                                                                                (case-lambda
-                                                                                                                  [(g937
-                                                                                                                    g938
-                                                                                                                    g939)
-                                                                                                                   ((top-level-value
-                                                                                                                      'call-with-values)
-                                                                                                                     (case-lambda
-                                                                                                                       [()
-                                                                                                                        (g816
-                                                                                                                          g937
-                                                                                                                          '#t)])
-                                                                                                                     (case-lambda
-                                                                                                                       [(g940
-                                                                                                                         g941
-                                                                                                                         g942)
-                                                                                                                        ((case-lambda
-                                                                                                                           [(g943)
-                                                                                                                            ((case-lambda
-                                                                                                                               [(g944)
-                                                                                                                                (if g944
-                                                                                                                                    (#%apply
-                                                                                                                                      (case-lambda
-                                                                                                                                        [(g945
-                                                                                                                                          g946
-                                                                                                                                          g947)
-                                                                                                                                         ((top-level-value
-                                                                                                                                            'values)
-                                                                                                                                           g940
-                                                                                                                                           (#%list
-                                                                                                                                             '#(syntax-object
-                                                                                                                                                begin
-                                                                                                                                                ((top)
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(d
-                                                                                                                                                      tmid
-                                                                                                                                                      other-id)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    ()
-                                                                                                                                                    ()
-                                                                                                                                                    ())
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(mid
-                                                                                                                                                      d
-                                                                                                                                                      exports)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(m
-                                                                                                                                                      new-id
-                                                                                                                                                      old-id)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(orig
-                                                                                                                                                      import-only?)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    ()
-                                                                                                                                                    ()
-                                                                                                                                                    ())
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(m
-                                                                                                                                                      exports?)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    (modspec*
-                                                                                                                                                      modspec
-                                                                                                                                                      gen-mid
-                                                                                                                                                      prefix-drop
-                                                                                                                                                      prefix-add
-                                                                                                                                                      difference)
-                                                                                                                                                    ((top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top)
-                                                                                                                                                      (top))
-                                                                                                                                                    ("i" "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"
-                                                                                                                                                         "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(r)
-                                                                                                                                                    #((top))
-                                                                                                                                                    #("i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    ()
-                                                                                                                                                    ()
-                                                                                                                                                    ())
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    #(orig
-                                                                                                                                                      import-only?)
-                                                                                                                                                    #((top)
-                                                                                                                                                      (top))
-                                                                                                                                                    #("i"
-                                                                                                                                                      "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    ($import-help
-                                                                                                                                                      $module-exports)
-                                                                                                                                                    ((top)
-                                                                                                                                                      (top))
-                                                                                                                                                    ("i" "i"))
-                                                                                                                                                  #(ribcage
-                                                                                                                                                    (lambda-var-list
-                                                                                                                                                     gen-var
-                                                                                                                                                     strip
-                                                                                                                                                     strip*
-                                                                                                                                                     strip-annotation
-                                                                                                                                                     ellipsis?
-                                                                                                                                                     chi-void
-                                                                                                                                                     chi-local-syntax
-                                                                                                                                                     chi-lambda-clause
-                                                                                                                                                     parse-begin
-                                                                                                                                                     parse-alias
-                                                                                                                                                     parse-eval-when
-                                                                                                                                                     parse-meta
-                                                                                                                                                     parse-define-syntax
-                                                                                                                                                     parse-define
-                                                                                                                                                     parse-import
-                                                                                                                                                     parse-module
-                                                                                                                                                     do-import!
-                                                                                                                                                     lookup-import-label
-                                                                                                                                                     import-mark-delta
-                                                                                                                                                     chi-internal
-                                                                                                                                                     chi-body
-                                                                                                                                                     chi-macro
-                                                                                                                                                     chi-set!
-                                                                                                                                                     chi-application
-                                                                                                                                                     chi-expr
-                                                                                                                                                     chi
-                                                                                                                                                     chi-sequence
-                                                                                                                                                     chi-meta-frob
-                                                                                                                                                     chi-frobs
-                                                                                                                                                     ct-eval/residualize3
-                                                                                                                                                     ct-eval/residualize2
-                                                                                                                                                     rt-eval/residualize
-                                                                                                                                                     initial-mode-set
-                                                                                                                                                     update-mode-set
-                                                                                                                                                     do-top-import
-                                                                                                                                                     vfor-each
-                                                                                                                                                     vmap
-                                                                                                                                                     chi-external
-                                                                                                                                                     check-defined-ids
-                                                                                                                                                     check-module-exports
-                                                                                                                                                     id-set-diff
-                                                                                                                                                     chi-top-module
-                                                                                                                                                     set-frob-meta?!
-                                                                                                                                                     set-frob-e!
-                                                                                                                                                     frob-meta?
-                                                                                                                                                     frob-e
-                                                                                                                                                     frob?
-                                                                                                                                                     make-frob
-                                                                                                                                                     create-module-binding
-                                                                                                                                                     set-module-binding-exported!
-                                                                                                                                                     set-module-binding-val!
-                                                                                                                                                     set-module-binding-imps!
-                                                                                                                                                     set-module-binding-label!
-                                                                                                                                                     set-module-binding-id!
-                                                                                                                                                     set-module-binding-type!
-                                                                                                                                                     module-binding-exported
-                                                                                                                                                     module-binding-val
-                                                                                                                                                     module-binding-imps
-                                                                                                                                                     module-binding-label
-                                                                                                                                                     module-binding-id
-                                                                                                                                                     module-binding-type
-                                                                                                                                                     module-binding?
-                                                                                                                                                     make-module-binding
-                                                                                                                                                     make-resolved-interface
-                                                                                                                                                     make-unresolved-interface
-                                                                                                                                                     set-interface-token!
-                                                                                                                                                     set-interface-exports!
-                                                                                                                                                     set-interface-marks!
-                                                                                                                                                     interface-token
-                                                                                                                                                     interface-exports
-                                                                                                                                                     interface-marks
-                                                                                                                                                     interface?
-                                                                                                                                                     make-interface
-                                                                                                                                                     flatten-exports
-                                                                                                                                                     chi-top
-                                                                                                                                                     chi-top-sequence
-                                                                                                                                                     chi-top*
-                                                                                                                                                     syntax-type
-                                                                                                                                                     chi-when-list
-                                                                                                                                                     source-wrap
-                                                                                                                                                     wrap
-                                                                                                                                                     bound-id-member?
-                                                                                                                                                     invalid-ids-error
-                                                                                                                                                     distinct-bound-ids?
-                                                                                                                                                     valid-bound-ids?
-                                                                                                                                                     bound-id=?
-                                                                                                                                                     help-bound-id=?
-                                                                                                                                                     literal-id=?
-                                                                                                                                                     free-id=?
-                                                                                                                                                     id-var-name
-                                                                                                                                                     id-var-name-loc
-                                                                                                                                                     id-var-name&marks
-                                                                                                                                                     id-var-name-loc&marks
-                                                                                                                                                     top-id-free-var-name
-                                                                                                                                                     top-id-bound-var-name
-                                                                                                                                                     anon
-                                                                                                                                                     diff-marks
-                                                                                                                                                     same-marks?
-                                                                                                                                                     join-subst
-                                                                                                                                                     join-marks
-                                                                                                                                                     join-wraps
-                                                                                                                                                     smart-append
-                                                                                                                                                     resolved-id-var-name
-                                                                                                                                                     id->resolved-id
-                                                                                                                                                     make-resolved-id
-                                                                                                                                                     make-binding-wrap
-                                                                                                                                                     store-import-binding
-                                                                                                                                                     lookup-import-binding-name
-                                                                                                                                                     extend-ribcage-subst!
-                                                                                                                                                     extend-ribcage-barrier-help!
-                                                                                                                                                     extend-ribcage-barrier!
-                                                                                                                                                     import-extend-ribcage!
-                                                                                                                                                     extend-ribcage!
-                                                                                                                                                     make-empty-ribcage
-                                                                                                                                                     barrier-marker
-                                                                                                                                                     new-mark
-                                                                                                                                                     anti-mark
-                                                                                                                                                     the-anti-mark
-                                                                                                                                                     set-env-wrap!
-                                                                                                                                                     set-env-top-ribcage!
-                                                                                                                                                     env-wrap
-                                                                                                                                                     env-top-ribcage
-                                                                                                                                                     env?
-                                                                                                                                                     make-env
-                                                                                                                                                     set-import-interface-new-marks!
-                                                                                                                                                     set-import-interface-interface!
-                                                                                                                                                     import-interface-new-marks
-                                                                                                                                                     import-interface-interface
-                                                                                                                                                     import-interface?
-                                                                                                                                                     make-import-interface
-                                                                                                                                                     set-top-ribcage-mutable?!
-                                                                                                                                                     set-top-ribcage-key!
-                                                                                                                                                     top-ribcage-mutable?
-                                                                                                                                                     top-ribcage-key
-                                                                                                                                                     top-ribcage?
-                                                                                                                                                     make-top-ribcage
-                                                                                                                                                     set-ribcage-labels!
-                                                                                                                                                     set-ribcage-marks!
-                                                                                                                                                     set-ribcage-symnames!
-                                                                                                                                                     ribcage-labels
-                                                                                                                                                     ribcage-marks
-                                                                                                                                                     ribcage-symnames
-                                                                                                                                                     ribcage?
-                                                                                                                                                     make-ribcage
-                                                                                                                                                     gen-labels
-                                                                                                                                                     label?
-                                                                                                                                                     gen-label
-                                                                                                                                                     set-indirect-label!
-                                                                                                                                                     get-indirect-label
-                                                                                                                                                     indirect-label?
-                                                                                                                                                     gen-indirect-label
-                                                                                                                                                     anon
-                                                                                                                                                     only-top-marked?
-                                                                                                                                                     top-marked?
-                                                                                                                                                     top-wrap
-                                                                                                                                                     empty-wrap
-                                                                                                                                                     wrap-subst
-                                                                                                                                                     wrap-marks
-                                                                                                                                                     make-wrap
-                                                                                                                                                     id-sym-name&marks
-                                                                                                                                                     id-subst
-                                                                                                                                                     id-marks
-                                                                                                                                                     id-sym-name
-                                                                                                                                                     id?
-                                                                                                                                                     nonsymbol-id?
-                                                                                                                                                     global-extend
-                                                                                                                                                     defer-or-eval-transformer
-                                                                                                                                                     make-transformer-binding
-                                                                                                                                                     lookup
-                                                                                                                                                     lookup*
-                                                                                                                                                     displaced-lexical-error
-                                                                                                                                                     displaced-lexical?
-                                                                                                                                                     extend-var-env*
-                                                                                                                                                     extend-env*
-                                                                                                                                                     extend-env
-                                                                                                                                                     null-env
-                                                                                                                                                     binding?
-                                                                                                                                                     set-binding-value!
-                                                                                                                                                     set-binding-type!
-                                                                                                                                                     binding-value
-                                                                                                                                                     binding-type
-                                                                                                                                                     make-binding
-                                                                                                                                                     sanitize-binding
-                                                                                                                                                     arg-check
-                                                                                                                                                     no-source
-                                                                                                                                                     unannotate
-                                                                                                                                                     self-evaluating?
-                                                                                                                                                     lexical-var?
-                                                                                                                                                     build-lexical-var
-                                                                                                                                                     build-top-module
-                                                                                                                                                     build-body
-                                                                                                                                                     build-letrec
-                                                                                                                                                     build-sequence
-                                                                                                                                                     build-data
-                                                                                                                                                     build-primref
-                                                                                                                                                     built-lambda?
-                                                                                                                                                     build-lambda
-                                                                                                                                                     build-revisit-only
-                                                                                                                                                     build-visit-only
-                                                                                                                                                     build-cte-install
-                                                                                                                                                     build-global-definition
-                                                                                                                                                     build-global-assignment
-                                                                                                                                                     build-global-reference
-                                                                                                                                                     build-lexical-assignment
-                                                                                                                                                     build-lexical-reference
-                                                                                                                                                     build-conditional
-                                                                                                                                                     build-application
-                                                                                                                                                     generate-id
-                                                                                                                                                     put-import-binding
-                                                                                                                                                     get-import-binding
-                                                                                                                                                     read-only-binding?
-                                                                                                                                                     put-global-definition-hook
-                                                                                                                                                     get-global-definition-hook
-                                                                                                                                                     put-cte-hook
-                                                                                                                                                     gensym-hook
-                                                                                                                                                     error-hook
-                                                                                                                                                     define-top-level-value-hook
-                                                                                                                                                     local-eval-hook
-                                                                                                                                                     top-level-eval-hook
-                                                                                                                                                     annotation?
-                                                                                                                                                     set-syntax-object-wrap!
-                                                                                                                                                     set-syntax-object-expression!
-                                                                                                                                                     syntax-object-wrap
-                                                                                                                                                     syntax-object-expression
-                                                                                                                                                     syntax-object?
-                                                                                                                                                     make-syntax-object
-                                                                                                                                                     noexpand
-                                                                                                                                                     let-values
-                                                                                                                                                     define-structure
-                                                                                                                                                     unless
-                                                                                                                                                     when)
-                                                                                                                                                    ((top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     ("m" top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     ("m" top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top)
-                                                                                                                                                     (top))
-                                                                                                                                                    ("i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"
-                                                                                                                                                     "i"))
-                                                                                                                                                  #(top-ribcage
-                                                                                                                                                    *top*
-                                                                                                                                                    #t)))
-                                                                                                                                             (#%cons
-                                                                                                                                               '#(syntax-object
-                                                                                                                                                  $module
-                                                                                                                                                  ((top)
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(d
-                                                                                                                                                        tmid
-                                                                                                                                                        other-id)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(mid
-                                                                                                                                                        d
-                                                                                                                                                        exports)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(m
-                                                                                                                                                        new-id
-                                                                                                                                                        old-id)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(orig
-                                                                                                                                                        import-only?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(m
-                                                                                                                                                        exports?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      (modspec*
-                                                                                                                                                        modspec
-                                                                                                                                                        gen-mid
-                                                                                                                                                        prefix-drop
-                                                                                                                                                        prefix-add
-                                                                                                                                                        difference)
-                                                                                                                                                      ((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      ("i" "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(r)
-                                                                                                                                                      #((top))
-                                                                                                                                                      #("i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(orig
-                                                                                                                                                        import-only?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ($import-help
-                                                                                                                                                        $module-exports)
-                                                                                                                                                      ((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      ("i" "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      (lambda-var-list
-                                                                                                                                                       gen-var
-                                                                                                                                                       strip
-                                                                                                                                                       strip*
-                                                                                                                                                       strip-annotation
-                                                                                                                                                       ellipsis?
-                                                                                                                                                       chi-void
-                                                                                                                                                       chi-local-syntax
-                                                                                                                                                       chi-lambda-clause
-                                                                                                                                                       parse-begin
-                                                                                                                                                       parse-alias
-                                                                                                                                                       parse-eval-when
-                                                                                                                                                       parse-meta
-                                                                                                                                                       parse-define-syntax
-                                                                                                                                                       parse-define
-                                                                                                                                                       parse-import
-                                                                                                                                                       parse-module
-                                                                                                                                                       do-import!
-                                                                                                                                                       lookup-import-label
-                                                                                                                                                       import-mark-delta
-                                                                                                                                                       chi-internal
-                                                                                                                                                       chi-body
-                                                                                                                                                       chi-macro
-                                                                                                                                                       chi-set!
-                                                                                                                                                       chi-application
-                                                                                                                                                       chi-expr
-                                                                                                                                                       chi
-                                                                                                                                                       chi-sequence
-                                                                                                                                                       chi-meta-frob
-                                                                                                                                                       chi-frobs
-                                                                                                                                                       ct-eval/residualize3
-                                                                                                                                                       ct-eval/residualize2
-                                                                                                                                                       rt-eval/residualize
-                                                                                                                                                       initial-mode-set
-                                                                                                                                                       update-mode-set
-                                                                                                                                                       do-top-import
-                                                                                                                                                       vfor-each
-                                                                                                                                                       vmap
-                                                                                                                                                       chi-external
-                                                                                                                                                       check-defined-ids
-                                                                                                                                                       check-module-exports
-                                                                                                                                                       id-set-diff
-                                                                                                                                                       chi-top-module
-                                                                                                                                                       set-frob-meta?!
-                                                                                                                                                       set-frob-e!
-                                                                                                                                                       frob-meta?
-                                                                                                                                                       frob-e
-                                                                                                                                                       frob?
-                                                                                                                                                       make-frob
-                                                                                                                                                       create-module-binding
-                                                                                                                                                       set-module-binding-exported!
-                                                                                                                                                       set-module-binding-val!
-                                                                                                                                                       set-module-binding-imps!
-                                                                                                                                                       set-module-binding-label!
-                                                                                                                                                       set-module-binding-id!
-                                                                                                                                                       set-module-binding-type!
-                                                                                                                                                       module-binding-exported
-                                                                                                                                                       module-binding-val
-                                                                                                                                                       module-binding-imps
-                                                                                                                                                       module-binding-label
-                                                                                                                                                       module-binding-id
-                                                                                                                                                       module-binding-type
-                                                                                                                                                       module-binding?
-                                                                                                                                                       make-module-binding
-                                                                                                                                                       make-resolved-interface
-                                                                                                                                                       make-unresolved-interface
-                                                                                                                                                       set-interface-token!
-                                                                                                                                                       set-interface-exports!
-                                                                                                                                                       set-interface-marks!
-                                                                                                                                                       interface-token
-                                                                                                                                                       interface-exports
-                                                                                                                                                       interface-marks
-                                                                                                                                                       interface?
-                                                                                                                                                       make-interface
-                                                                                                                                                       flatten-exports
-                                                                                                                                                       chi-top
-                                                                                                                                                       chi-top-sequence
-                                                                                                                                                       chi-top*
-                                                                                                                                                       syntax-type
-                                                                                                                                                       chi-when-list
-                                                                                                                                                       source-wrap
-                                                                                                                                                       wrap
-                                                                                                                                                       bound-id-member?
-                                                                                                                                                       invalid-ids-error
-                                                                                                                                                       distinct-bound-ids?
-                                                                                                                                                       valid-bound-ids?
-                                                                                                                                                       bound-id=?
-                                                                                                                                                       help-bound-id=?
-                                                                                                                                                       literal-id=?
-                                                                                                                                                       free-id=?
-                                                                                                                                                       id-var-name
-                                                                                                                                                       id-var-name-loc
-                                                                                                                                                       id-var-name&marks
-                                                                                                                                                       id-var-name-loc&marks
-                                                                                                                                                       top-id-free-var-name
-                                                                                                                                                       top-id-bound-var-name
-                                                                                                                                                       anon
-                                                                                                                                                       diff-marks
-                                                                                                                                                       same-marks?
-                                                                                                                                                       join-subst
-                                                                                                                                                       join-marks
-                                                                                                                                                       join-wraps
-                                                                                                                                                       smart-append
-                                                                                                                                                       resolved-id-var-name
-                                                                                                                                                       id->resolved-id
-                                                                                                                                                       make-resolved-id
-                                                                                                                                                       make-binding-wrap
-                                                                                                                                                       store-import-binding
-                                                                                                                                                       lookup-import-binding-name
-                                                                                                                                                       extend-ribcage-subst!
-                                                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                                                       extend-ribcage-barrier!
-                                                                                                                                                       import-extend-ribcage!
-                                                                                                                                                       extend-ribcage!
-                                                                                                                                                       make-empty-ribcage
-                                                                                                                                                       barrier-marker
-                                                                                                                                                       new-mark
-                                                                                                                                                       anti-mark
-                                                                                                                                                       the-anti-mark
-                                                                                                                                                       set-env-wrap!
-                                                                                                                                                       set-env-top-ribcage!
-                                                                                                                                                       env-wrap
-                                                                                                                                                       env-top-ribcage
-                                                                                                                                                       env?
-                                                                                                                                                       make-env
-                                                                                                                                                       set-import-interface-new-marks!
-                                                                                                                                                       set-import-interface-interface!
-                                                                                                                                                       import-interface-new-marks
-                                                                                                                                                       import-interface-interface
-                                                                                                                                                       import-interface?
-                                                                                                                                                       make-import-interface
-                                                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                                                       set-top-ribcage-key!
-                                                                                                                                                       top-ribcage-mutable?
-                                                                                                                                                       top-ribcage-key
-                                                                                                                                                       top-ribcage?
-                                                                                                                                                       make-top-ribcage
-                                                                                                                                                       set-ribcage-labels!
-                                                                                                                                                       set-ribcage-marks!
-                                                                                                                                                       set-ribcage-symnames!
-                                                                                                                                                       ribcage-labels
-                                                                                                                                                       ribcage-marks
-                                                                                                                                                       ribcage-symnames
-                                                                                                                                                       ribcage?
-                                                                                                                                                       make-ribcage
-                                                                                                                                                       gen-labels
-                                                                                                                                                       label?
-                                                                                                                                                       gen-label
-                                                                                                                                                       set-indirect-label!
-                                                                                                                                                       get-indirect-label
-                                                                                                                                                       indirect-label?
-                                                                                                                                                       gen-indirect-label
-                                                                                                                                                       anon
-                                                                                                                                                       only-top-marked?
-                                                                                                                                                       top-marked?
-                                                                                                                                                       top-wrap
-                                                                                                                                                       empty-wrap
-                                                                                                                                                       wrap-subst
-                                                                                                                                                       wrap-marks
-                                                                                                                                                       make-wrap
-                                                                                                                                                       id-sym-name&marks
-                                                                                                                                                       id-subst
-                                                                                                                                                       id-marks
-                                                                                                                                                       id-sym-name
-                                                                                                                                                       id?
-                                                                                                                                                       nonsymbol-id?
-                                                                                                                                                       global-extend
-                                                                                                                                                       defer-or-eval-transformer
-                                                                                                                                                       make-transformer-binding
-                                                                                                                                                       lookup
-                                                                                                                                                       lookup*
-                                                                                                                                                       displaced-lexical-error
-                                                                                                                                                       displaced-lexical?
-                                                                                                                                                       extend-var-env*
-                                                                                                                                                       extend-env*
-                                                                                                                                                       extend-env
-                                                                                                                                                       null-env
-                                                                                                                                                       binding?
-                                                                                                                                                       set-binding-value!
-                                                                                                                                                       set-binding-type!
-                                                                                                                                                       binding-value
-                                                                                                                                                       binding-type
-                                                                                                                                                       make-binding
-                                                                                                                                                       sanitize-binding
-                                                                                                                                                       arg-check
-                                                                                                                                                       no-source
-                                                                                                                                                       unannotate
-                                                                                                                                                       self-evaluating?
-                                                                                                                                                       lexical-var?
-                                                                                                                                                       build-lexical-var
-                                                                                                                                                       build-top-module
-                                                                                                                                                       build-body
-                                                                                                                                                       build-letrec
-                                                                                                                                                       build-sequence
-                                                                                                                                                       build-data
-                                                                                                                                                       build-primref
-                                                                                                                                                       built-lambda?
-                                                                                                                                                       build-lambda
-                                                                                                                                                       build-revisit-only
-                                                                                                                                                       build-visit-only
-                                                                                                                                                       build-cte-install
-                                                                                                                                                       build-global-definition
-                                                                                                                                                       build-global-assignment
-                                                                                                                                                       build-global-reference
-                                                                                                                                                       build-lexical-assignment
-                                                                                                                                                       build-lexical-reference
-                                                                                                                                                       build-conditional
-                                                                                                                                                       build-application
-                                                                                                                                                       generate-id
-                                                                                                                                                       put-import-binding
-                                                                                                                                                       get-import-binding
-                                                                                                                                                       read-only-binding?
-                                                                                                                                                       put-global-definition-hook
-                                                                                                                                                       get-global-definition-hook
-                                                                                                                                                       put-cte-hook
-                                                                                                                                                       gensym-hook
-                                                                                                                                                       error-hook
-                                                                                                                                                       define-top-level-value-hook
-                                                                                                                                                       local-eval-hook
-                                                                                                                                                       top-level-eval-hook
-                                                                                                                                                       annotation?
-                                                                                                                                                       set-syntax-object-wrap!
-                                                                                                                                                       set-syntax-object-expression!
-                                                                                                                                                       syntax-object-wrap
-                                                                                                                                                       syntax-object-expression
-                                                                                                                                                       syntax-object?
-                                                                                                                                                       make-syntax-object
-                                                                                                                                                       noexpand
-                                                                                                                                                       let-values
-                                                                                                                                                       define-structure
-                                                                                                                                                       unless
-                                                                                                                                                       when)
-                                                                                                                                                      ((top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       ("m" top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       ("m" top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top))
-                                                                                                                                                      ("i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"))
-                                                                                                                                                    #(top-ribcage
-                                                                                                                                                      *top*
-                                                                                                                                                      #t)))
-                                                                                                                                               (#%cons
-                                                                                                                                                 g847
-                                                                                                                                                 (#%cons
-                                                                                                                                                   g946
-                                                                                                                                                   (#%cons
-                                                                                                                                                     (#%append
-                                                                                                                                                       (#%map
-                                                                                                                                                         #%list
-                                                                                                                                                         g938
-                                                                                                                                                         g939)
-                                                                                                                                                       g947)
-                                                                                                                                                     (#%cons
-                                                                                                                                                       g945
-                                                                                                                                                       (#%map
-                                                                                                                                                         (case-lambda
-                                                                                                                                                           [(g948
-                                                                                                                                                             g949)
-                                                                                                                                                            (#%list
-                                                                                                                                                              '#(syntax-object
-                                                                                                                                                                 alias
-                                                                                                                                                                 ((top)
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(d
-                                                                                                                                                                       tmid
-                                                                                                                                                                       other-id)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     ()
-                                                                                                                                                                     ()
-                                                                                                                                                                     ())
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(mid
-                                                                                                                                                                       d
-                                                                                                                                                                       exports)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(m
-                                                                                                                                                                       new-id
-                                                                                                                                                                       old-id)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(orig
-                                                                                                                                                                       import-only?)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     ()
-                                                                                                                                                                     ()
-                                                                                                                                                                     ())
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(m
-                                                                                                                                                                       exports?)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     (modspec*
-                                                                                                                                                                       modspec
-                                                                                                                                                                       gen-mid
-                                                                                                                                                                       prefix-drop
-                                                                                                                                                                       prefix-add
-                                                                                                                                                                       difference)
-                                                                                                                                                                     ((top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     ("i" "i"
-                                                                                                                                                                          "i"
-                                                                                                                                                                          "i"
-                                                                                                                                                                          "i"
-                                                                                                                                                                          "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(r)
-                                                                                                                                                                     #((top))
-                                                                                                                                                                     #("i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     ()
-                                                                                                                                                                     ()
-                                                                                                                                                                     ())
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     #(orig
-                                                                                                                                                                       import-only?)
-                                                                                                                                                                     #((top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     #("i"
-                                                                                                                                                                       "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     ($import-help
-                                                                                                                                                                       $module-exports)
-                                                                                                                                                                     ((top)
-                                                                                                                                                                       (top))
-                                                                                                                                                                     ("i" "i"))
-                                                                                                                                                                   #(ribcage
-                                                                                                                                                                     (lambda-var-list
-                                                                                                                                                                      gen-var
-                                                                                                                                                                      strip
-                                                                                                                                                                      strip*
-                                                                                                                                                                      strip-annotation
-                                                                                                                                                                      ellipsis?
-                                                                                                                                                                      chi-void
-                                                                                                                                                                      chi-local-syntax
-                                                                                                                                                                      chi-lambda-clause
-                                                                                                                                                                      parse-begin
-                                                                                                                                                                      parse-alias
-                                                                                                                                                                      parse-eval-when
-                                                                                                                                                                      parse-meta
-                                                                                                                                                                      parse-define-syntax
-                                                                                                                                                                      parse-define
-                                                                                                                                                                      parse-import
-                                                                                                                                                                      parse-module
-                                                                                                                                                                      do-import!
-                                                                                                                                                                      lookup-import-label
-                                                                                                                                                                      import-mark-delta
-                                                                                                                                                                      chi-internal
-                                                                                                                                                                      chi-body
-                                                                                                                                                                      chi-macro
-                                                                                                                                                                      chi-set!
-                                                                                                                                                                      chi-application
-                                                                                                                                                                      chi-expr
-                                                                                                                                                                      chi
-                                                                                                                                                                      chi-sequence
-                                                                                                                                                                      chi-meta-frob
-                                                                                                                                                                      chi-frobs
-                                                                                                                                                                      ct-eval/residualize3
-                                                                                                                                                                      ct-eval/residualize2
-                                                                                                                                                                      rt-eval/residualize
-                                                                                                                                                                      initial-mode-set
-                                                                                                                                                                      update-mode-set
-                                                                                                                                                                      do-top-import
-                                                                                                                                                                      vfor-each
-                                                                                                                                                                      vmap
-                                                                                                                                                                      chi-external
-                                                                                                                                                                      check-defined-ids
-                                                                                                                                                                      check-module-exports
-                                                                                                                                                                      id-set-diff
-                                                                                                                                                                      chi-top-module
-                                                                                                                                                                      set-frob-meta?!
-                                                                                                                                                                      set-frob-e!
-                                                                                                                                                                      frob-meta?
-                                                                                                                                                                      frob-e
-                                                                                                                                                                      frob?
-                                                                                                                                                                      make-frob
-                                                                                                                                                                      create-module-binding
-                                                                                                                                                                      set-module-binding-exported!
-                                                                                                                                                                      set-module-binding-val!
-                                                                                                                                                                      set-module-binding-imps!
-                                                                                                                                                                      set-module-binding-label!
-                                                                                                                                                                      set-module-binding-id!
-                                                                                                                                                                      set-module-binding-type!
-                                                                                                                                                                      module-binding-exported
-                                                                                                                                                                      module-binding-val
-                                                                                                                                                                      module-binding-imps
-                                                                                                                                                                      module-binding-label
-                                                                                                                                                                      module-binding-id
-                                                                                                                                                                      module-binding-type
-                                                                                                                                                                      module-binding?
-                                                                                                                                                                      make-module-binding
-                                                                                                                                                                      make-resolved-interface
-                                                                                                                                                                      make-unresolved-interface
-                                                                                                                                                                      set-interface-token!
-                                                                                                                                                                      set-interface-exports!
-                                                                                                                                                                      set-interface-marks!
-                                                                                                                                                                      interface-token
-                                                                                                                                                                      interface-exports
-                                                                                                                                                                      interface-marks
-                                                                                                                                                                      interface?
-                                                                                                                                                                      make-interface
-                                                                                                                                                                      flatten-exports
-                                                                                                                                                                      chi-top
-                                                                                                                                                                      chi-top-sequence
-                                                                                                                                                                      chi-top*
-                                                                                                                                                                      syntax-type
-                                                                                                                                                                      chi-when-list
-                                                                                                                                                                      source-wrap
-                                                                                                                                                                      wrap
-                                                                                                                                                                      bound-id-member?
-                                                                                                                                                                      invalid-ids-error
-                                                                                                                                                                      distinct-bound-ids?
-                                                                                                                                                                      valid-bound-ids?
-                                                                                                                                                                      bound-id=?
-                                                                                                                                                                      help-bound-id=?
-                                                                                                                                                                      literal-id=?
-                                                                                                                                                                      free-id=?
-                                                                                                                                                                      id-var-name
-                                                                                                                                                                      id-var-name-loc
-                                                                                                                                                                      id-var-name&marks
-                                                                                                                                                                      id-var-name-loc&marks
-                                                                                                                                                                      top-id-free-var-name
-                                                                                                                                                                      top-id-bound-var-name
-                                                                                                                                                                      anon
-                                                                                                                                                                      diff-marks
-                                                                                                                                                                      same-marks?
-                                                                                                                                                                      join-subst
-                                                                                                                                                                      join-marks
-                                                                                                                                                                      join-wraps
-                                                                                                                                                                      smart-append
-                                                                                                                                                                      resolved-id-var-name
-                                                                                                                                                                      id->resolved-id
-                                                                                                                                                                      make-resolved-id
-                                                                                                                                                                      make-binding-wrap
-                                                                                                                                                                      store-import-binding
-                                                                                                                                                                      lookup-import-binding-name
-                                                                                                                                                                      extend-ribcage-subst!
-                                                                                                                                                                      extend-ribcage-barrier-help!
-                                                                                                                                                                      extend-ribcage-barrier!
-                                                                                                                                                                      import-extend-ribcage!
-                                                                                                                                                                      extend-ribcage!
-                                                                                                                                                                      make-empty-ribcage
-                                                                                                                                                                      barrier-marker
-                                                                                                                                                                      new-mark
-                                                                                                                                                                      anti-mark
-                                                                                                                                                                      the-anti-mark
-                                                                                                                                                                      set-env-wrap!
-                                                                                                                                                                      set-env-top-ribcage!
-                                                                                                                                                                      env-wrap
-                                                                                                                                                                      env-top-ribcage
-                                                                                                                                                                      env?
-                                                                                                                                                                      make-env
-                                                                                                                                                                      set-import-interface-new-marks!
-                                                                                                                                                                      set-import-interface-interface!
-                                                                                                                                                                      import-interface-new-marks
-                                                                                                                                                                      import-interface-interface
-                                                                                                                                                                      import-interface?
-                                                                                                                                                                      make-import-interface
-                                                                                                                                                                      set-top-ribcage-mutable?!
-                                                                                                                                                                      set-top-ribcage-key!
-                                                                                                                                                                      top-ribcage-mutable?
-                                                                                                                                                                      top-ribcage-key
-                                                                                                                                                                      top-ribcage?
-                                                                                                                                                                      make-top-ribcage
-                                                                                                                                                                      set-ribcage-labels!
-                                                                                                                                                                      set-ribcage-marks!
-                                                                                                                                                                      set-ribcage-symnames!
-                                                                                                                                                                      ribcage-labels
-                                                                                                                                                                      ribcage-marks
-                                                                                                                                                                      ribcage-symnames
-                                                                                                                                                                      ribcage?
-                                                                                                                                                                      make-ribcage
-                                                                                                                                                                      gen-labels
-                                                                                                                                                                      label?
-                                                                                                                                                                      gen-label
-                                                                                                                                                                      set-indirect-label!
-                                                                                                                                                                      get-indirect-label
-                                                                                                                                                                      indirect-label?
-                                                                                                                                                                      gen-indirect-label
-                                                                                                                                                                      anon
-                                                                                                                                                                      only-top-marked?
-                                                                                                                                                                      top-marked?
-                                                                                                                                                                      top-wrap
-                                                                                                                                                                      empty-wrap
-                                                                                                                                                                      wrap-subst
-                                                                                                                                                                      wrap-marks
-                                                                                                                                                                      make-wrap
-                                                                                                                                                                      id-sym-name&marks
-                                                                                                                                                                      id-subst
-                                                                                                                                                                      id-marks
-                                                                                                                                                                      id-sym-name
-                                                                                                                                                                      id?
-                                                                                                                                                                      nonsymbol-id?
-                                                                                                                                                                      global-extend
-                                                                                                                                                                      defer-or-eval-transformer
-                                                                                                                                                                      make-transformer-binding
-                                                                                                                                                                      lookup
-                                                                                                                                                                      lookup*
-                                                                                                                                                                      displaced-lexical-error
-                                                                                                                                                                      displaced-lexical?
-                                                                                                                                                                      extend-var-env*
-                                                                                                                                                                      extend-env*
-                                                                                                                                                                      extend-env
-                                                                                                                                                                      null-env
-                                                                                                                                                                      binding?
-                                                                                                                                                                      set-binding-value!
-                                                                                                                                                                      set-binding-type!
-                                                                                                                                                                      binding-value
-                                                                                                                                                                      binding-type
-                                                                                                                                                                      make-binding
-                                                                                                                                                                      sanitize-binding
-                                                                                                                                                                      arg-check
-                                                                                                                                                                      no-source
-                                                                                                                                                                      unannotate
-                                                                                                                                                                      self-evaluating?
-                                                                                                                                                                      lexical-var?
-                                                                                                                                                                      build-lexical-var
-                                                                                                                                                                      build-top-module
-                                                                                                                                                                      build-body
-                                                                                                                                                                      build-letrec
-                                                                                                                                                                      build-sequence
-                                                                                                                                                                      build-data
-                                                                                                                                                                      build-primref
-                                                                                                                                                                      built-lambda?
-                                                                                                                                                                      build-lambda
-                                                                                                                                                                      build-revisit-only
-                                                                                                                                                                      build-visit-only
-                                                                                                                                                                      build-cte-install
-                                                                                                                                                                      build-global-definition
-                                                                                                                                                                      build-global-assignment
-                                                                                                                                                                      build-global-reference
-                                                                                                                                                                      build-lexical-assignment
-                                                                                                                                                                      build-lexical-reference
-                                                                                                                                                                      build-conditional
-                                                                                                                                                                      build-application
-                                                                                                                                                                      generate-id
-                                                                                                                                                                      put-import-binding
-                                                                                                                                                                      get-import-binding
-                                                                                                                                                                      read-only-binding?
-                                                                                                                                                                      put-global-definition-hook
-                                                                                                                                                                      get-global-definition-hook
-                                                                                                                                                                      put-cte-hook
-                                                                                                                                                                      gensym-hook
-                                                                                                                                                                      error-hook
-                                                                                                                                                                      define-top-level-value-hook
-                                                                                                                                                                      local-eval-hook
-                                                                                                                                                                      top-level-eval-hook
-                                                                                                                                                                      annotation?
-                                                                                                                                                                      set-syntax-object-wrap!
-                                                                                                                                                                      set-syntax-object-expression!
-                                                                                                                                                                      syntax-object-wrap
-                                                                                                                                                                      syntax-object-expression
-                                                                                                                                                                      syntax-object?
-                                                                                                                                                                      make-syntax-object
-                                                                                                                                                                      noexpand
-                                                                                                                                                                      let-values
-                                                                                                                                                                      define-structure
-                                                                                                                                                                      unless
-                                                                                                                                                                      when)
-                                                                                                                                                                     ((top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      ("m" top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      ("m" top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top)
-                                                                                                                                                                      (top))
-                                                                                                                                                                     ("i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"
-                                                                                                                                                                      "i"))
-                                                                                                                                                                   #(top-ribcage
-                                                                                                                                                                     *top*
-                                                                                                                                                                     #t)))
-                                                                                                                                                              g949
-                                                                                                                                                              g948)])
-                                                                                                                                                         g939
-                                                                                                                                                         g938))))))
-                                                                                                                                             (#%list
-                                                                                                                                               '#(syntax-object
-                                                                                                                                                  $import
-                                                                                                                                                  ((top)
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(d
-                                                                                                                                                        tmid
-                                                                                                                                                        other-id)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(mid
-                                                                                                                                                        d
-                                                                                                                                                        exports)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(m
-                                                                                                                                                        new-id
-                                                                                                                                                        old-id)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(orig
-                                                                                                                                                        import-only?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(m
-                                                                                                                                                        exports?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      (modspec*
-                                                                                                                                                        modspec
-                                                                                                                                                        gen-mid
-                                                                                                                                                        prefix-drop
-                                                                                                                                                        prefix-add
-                                                                                                                                                        difference)
-                                                                                                                                                      ((top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top)
-                                                                                                                                                        (top))
-                                                                                                                                                      ("i" "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"
-                                                                                                                                                           "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(r)
-                                                                                                                                                      #((top))
-                                                                                                                                                      #("i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ()
-                                                                                                                                                      ()
-                                                                                                                                                      ())
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      #(orig
-                                                                                                                                                        import-only?)
-                                                                                                                                                      #((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      #("i"
-                                                                                                                                                        "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      ($import-help
-                                                                                                                                                        $module-exports)
-                                                                                                                                                      ((top)
-                                                                                                                                                        (top))
-                                                                                                                                                      ("i" "i"))
-                                                                                                                                                    #(ribcage
-                                                                                                                                                      (lambda-var-list
-                                                                                                                                                       gen-var
-                                                                                                                                                       strip
-                                                                                                                                                       strip*
-                                                                                                                                                       strip-annotation
-                                                                                                                                                       ellipsis?
-                                                                                                                                                       chi-void
-                                                                                                                                                       chi-local-syntax
-                                                                                                                                                       chi-lambda-clause
-                                                                                                                                                       parse-begin
-                                                                                                                                                       parse-alias
-                                                                                                                                                       parse-eval-when
-                                                                                                                                                       parse-meta
-                                                                                                                                                       parse-define-syntax
-                                                                                                                                                       parse-define
-                                                                                                                                                       parse-import
-                                                                                                                                                       parse-module
-                                                                                                                                                       do-import!
-                                                                                                                                                       lookup-import-label
-                                                                                                                                                       import-mark-delta
-                                                                                                                                                       chi-internal
-                                                                                                                                                       chi-body
-                                                                                                                                                       chi-macro
-                                                                                                                                                       chi-set!
-                                                                                                                                                       chi-application
-                                                                                                                                                       chi-expr
-                                                                                                                                                       chi
-                                                                                                                                                       chi-sequence
-                                                                                                                                                       chi-meta-frob
-                                                                                                                                                       chi-frobs
-                                                                                                                                                       ct-eval/residualize3
-                                                                                                                                                       ct-eval/residualize2
-                                                                                                                                                       rt-eval/residualize
-                                                                                                                                                       initial-mode-set
-                                                                                                                                                       update-mode-set
-                                                                                                                                                       do-top-import
-                                                                                                                                                       vfor-each
-                                                                                                                                                       vmap
-                                                                                                                                                       chi-external
-                                                                                                                                                       check-defined-ids
-                                                                                                                                                       check-module-exports
-                                                                                                                                                       id-set-diff
-                                                                                                                                                       chi-top-module
-                                                                                                                                                       set-frob-meta?!
-                                                                                                                                                       set-frob-e!
-                                                                                                                                                       frob-meta?
-                                                                                                                                                       frob-e
-                                                                                                                                                       frob?
-                                                                                                                                                       make-frob
-                                                                                                                                                       create-module-binding
-                                                                                                                                                       set-module-binding-exported!
-                                                                                                                                                       set-module-binding-val!
-                                                                                                                                                       set-module-binding-imps!
-                                                                                                                                                       set-module-binding-label!
-                                                                                                                                                       set-module-binding-id!
-                                                                                                                                                       set-module-binding-type!
-                                                                                                                                                       module-binding-exported
-                                                                                                                                                       module-binding-val
-                                                                                                                                                       module-binding-imps
-                                                                                                                                                       module-binding-label
-                                                                                                                                                       module-binding-id
-                                                                                                                                                       module-binding-type
-                                                                                                                                                       module-binding?
-                                                                                                                                                       make-module-binding
-                                                                                                                                                       make-resolved-interface
-                                                                                                                                                       make-unresolved-interface
-                                                                                                                                                       set-interface-token!
-                                                                                                                                                       set-interface-exports!
-                                                                                                                                                       set-interface-marks!
-                                                                                                                                                       interface-token
-                                                                                                                                                       interface-exports
-                                                                                                                                                       interface-marks
-                                                                                                                                                       interface?
-                                                                                                                                                       make-interface
-                                                                                                                                                       flatten-exports
-                                                                                                                                                       chi-top
-                                                                                                                                                       chi-top-sequence
-                                                                                                                                                       chi-top*
-                                                                                                                                                       syntax-type
-                                                                                                                                                       chi-when-list
-                                                                                                                                                       source-wrap
-                                                                                                                                                       wrap
-                                                                                                                                                       bound-id-member?
-                                                                                                                                                       invalid-ids-error
-                                                                                                                                                       distinct-bound-ids?
-                                                                                                                                                       valid-bound-ids?
-                                                                                                                                                       bound-id=?
-                                                                                                                                                       help-bound-id=?
-                                                                                                                                                       literal-id=?
-                                                                                                                                                       free-id=?
-                                                                                                                                                       id-var-name
-                                                                                                                                                       id-var-name-loc
-                                                                                                                                                       id-var-name&marks
-                                                                                                                                                       id-var-name-loc&marks
-                                                                                                                                                       top-id-free-var-name
-                                                                                                                                                       top-id-bound-var-name
-                                                                                                                                                       anon
-                                                                                                                                                       diff-marks
-                                                                                                                                                       same-marks?
-                                                                                                                                                       join-subst
-                                                                                                                                                       join-marks
-                                                                                                                                                       join-wraps
-                                                                                                                                                       smart-append
-                                                                                                                                                       resolved-id-var-name
-                                                                                                                                                       id->resolved-id
-                                                                                                                                                       make-resolved-id
-                                                                                                                                                       make-binding-wrap
-                                                                                                                                                       store-import-binding
-                                                                                                                                                       lookup-import-binding-name
-                                                                                                                                                       extend-ribcage-subst!
-                                                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                                                       extend-ribcage-barrier!
-                                                                                                                                                       import-extend-ribcage!
-                                                                                                                                                       extend-ribcage!
-                                                                                                                                                       make-empty-ribcage
-                                                                                                                                                       barrier-marker
-                                                                                                                                                       new-mark
-                                                                                                                                                       anti-mark
-                                                                                                                                                       the-anti-mark
-                                                                                                                                                       set-env-wrap!
-                                                                                                                                                       set-env-top-ribcage!
-                                                                                                                                                       env-wrap
-                                                                                                                                                       env-top-ribcage
-                                                                                                                                                       env?
-                                                                                                                                                       make-env
-                                                                                                                                                       set-import-interface-new-marks!
-                                                                                                                                                       set-import-interface-interface!
-                                                                                                                                                       import-interface-new-marks
-                                                                                                                                                       import-interface-interface
-                                                                                                                                                       import-interface?
-                                                                                                                                                       make-import-interface
-                                                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                                                       set-top-ribcage-key!
-                                                                                                                                                       top-ribcage-mutable?
-                                                                                                                                                       top-ribcage-key
-                                                                                                                                                       top-ribcage?
-                                                                                                                                                       make-top-ribcage
-                                                                                                                                                       set-ribcage-labels!
-                                                                                                                                                       set-ribcage-marks!
-                                                                                                                                                       set-ribcage-symnames!
-                                                                                                                                                       ribcage-labels
-                                                                                                                                                       ribcage-marks
-                                                                                                                                                       ribcage-symnames
-                                                                                                                                                       ribcage?
-                                                                                                                                                       make-ribcage
-                                                                                                                                                       gen-labels
-                                                                                                                                                       label?
-                                                                                                                                                       gen-label
-                                                                                                                                                       set-indirect-label!
-                                                                                                                                                       get-indirect-label
-                                                                                                                                                       indirect-label?
-                                                                                                                                                       gen-indirect-label
-                                                                                                                                                       anon
-                                                                                                                                                       only-top-marked?
-                                                                                                                                                       top-marked?
-                                                                                                                                                       top-wrap
-                                                                                                                                                       empty-wrap
-                                                                                                                                                       wrap-subst
-                                                                                                                                                       wrap-marks
-                                                                                                                                                       make-wrap
-                                                                                                                                                       id-sym-name&marks
-                                                                                                                                                       id-subst
-                                                                                                                                                       id-marks
-                                                                                                                                                       id-sym-name
-                                                                                                                                                       id?
-                                                                                                                                                       nonsymbol-id?
-                                                                                                                                                       global-extend
-                                                                                                                                                       defer-or-eval-transformer
-                                                                                                                                                       make-transformer-binding
-                                                                                                                                                       lookup
-                                                                                                                                                       lookup*
-                                                                                                                                                       displaced-lexical-error
-                                                                                                                                                       displaced-lexical?
-                                                                                                                                                       extend-var-env*
-                                                                                                                                                       extend-env*
-                                                                                                                                                       extend-env
-                                                                                                                                                       null-env
-                                                                                                                                                       binding?
-                                                                                                                                                       set-binding-value!
-                                                                                                                                                       set-binding-type!
-                                                                                                                                                       binding-value
-                                                                                                                                                       binding-type
-                                                                                                                                                       make-binding
-                                                                                                                                                       sanitize-binding
-                                                                                                                                                       arg-check
-                                                                                                                                                       no-source
-                                                                                                                                                       unannotate
-                                                                                                                                                       self-evaluating?
-                                                                                                                                                       lexical-var?
-                                                                                                                                                       build-lexical-var
-                                                                                                                                                       build-top-module
-                                                                                                                                                       build-body
-                                                                                                                                                       build-letrec
-                                                                                                                                                       build-sequence
-                                                                                                                                                       build-data
-                                                                                                                                                       build-primref
-                                                                                                                                                       built-lambda?
-                                                                                                                                                       build-lambda
-                                                                                                                                                       build-revisit-only
-                                                                                                                                                       build-visit-only
-                                                                                                                                                       build-cte-install
-                                                                                                                                                       build-global-definition
-                                                                                                                                                       build-global-assignment
-                                                                                                                                                       build-global-reference
-                                                                                                                                                       build-lexical-assignment
-                                                                                                                                                       build-lexical-reference
-                                                                                                                                                       build-conditional
-                                                                                                                                                       build-application
-                                                                                                                                                       generate-id
-                                                                                                                                                       put-import-binding
-                                                                                                                                                       get-import-binding
-                                                                                                                                                       read-only-binding?
-                                                                                                                                                       put-global-definition-hook
-                                                                                                                                                       get-global-definition-hook
-                                                                                                                                                       put-cte-hook
-                                                                                                                                                       gensym-hook
-                                                                                                                                                       error-hook
-                                                                                                                                                       define-top-level-value-hook
-                                                                                                                                                       local-eval-hook
-                                                                                                                                                       top-level-eval-hook
-                                                                                                                                                       annotation?
-                                                                                                                                                       set-syntax-object-wrap!
-                                                                                                                                                       set-syntax-object-expression!
-                                                                                                                                                       syntax-object-wrap
-                                                                                                                                                       syntax-object-expression
-                                                                                                                                                       syntax-object?
-                                                                                                                                                       make-syntax-object
-                                                                                                                                                       noexpand
-                                                                                                                                                       let-values
-                                                                                                                                                       define-structure
-                                                                                                                                                       unless
-                                                                                                                                                       when)
-                                                                                                                                                      ((top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       ("m" top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       ("m" top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top)
-                                                                                                                                                       (top))
-                                                                                                                                                      ("i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"
-                                                                                                                                                       "i"))
-                                                                                                                                                    #(top-ribcage
-                                                                                                                                                      *top*
-                                                                                                                                                      #t)))
-                                                                                                                                               g847
-                                                                                                                                               g848
-                                                                                                                                               g946))
-                                                                                                                                           (if g844
-                                                                                                                                               (#%append
-                                                                                                                                                 g938
-                                                                                                                                                 g947)
-                                                                                                                                               '#f))])
-                                                                                                                                      g944)
-                                                                                                                                    (#%syntax-error
-                                                                                                                                      g943))])
-                                                                                                                              (#%$syntax-dispatch
-                                                                                                                                g943
-                                                                                                                                '(any any
-                                                                                                                                      each-any)))])
-                                                                                                                          ((top-level-value
-                                                                                                                             'list)
-                                                                                                                            g941
-                                                                                                                            (g815
-                                                                                                                              g940)
-                                                                                                                            g942))]))])
-                                                                                                                g933)
-                                                                                                              ((case-lambda
-                                                                                                                 [(g950)
-                                                                                                                  (if (if g950
-                                                                                                                          (#%apply
-                                                                                                                            (case-lambda
-                                                                                                                              [(g951)
-                                                                                                                               ((top-level-value
-                                                                                                                                  'identifier?)
-                                                                                                                                 g951)])
-                                                                                                                            g950)
-                                                                                                                          '#f)
-                                                                                                                      (#%apply
-                                                                                                                        (case-lambda
-                                                                                                                          [(g952)
-                                                                                                                           ((top-level-value
-                                                                                                                              'values)
-                                                                                                                             g952
-                                                                                                                             (#%list
-                                                                                                                               '#(syntax-object
-                                                                                                                                  $import
-                                                                                                                                  ((top)
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(mid)
-                                                                                                                                      #((top))
-                                                                                                                                      #("i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(m
-                                                                                                                                        exports?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (modspec*
-                                                                                                                                        modspec
-                                                                                                                                        gen-mid
-                                                                                                                                        prefix-drop
-                                                                                                                                        prefix-add
-                                                                                                                                        difference)
-                                                                                                                                      ((top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"
-                                                                                                                                           "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(r)
-                                                                                                                                      #((top))
-                                                                                                                                      #("i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ()
-                                                                                                                                      ()
-                                                                                                                                      ())
-                                                                                                                                    #(ribcage
-                                                                                                                                      #(orig
-                                                                                                                                        import-only?)
-                                                                                                                                      #((top)
-                                                                                                                                        (top))
-                                                                                                                                      #("i"
-                                                                                                                                        "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      ($import-help
-                                                                                                                                        $module-exports)
-                                                                                                                                      ((top)
-                                                                                                                                        (top))
-                                                                                                                                      ("i" "i"))
-                                                                                                                                    #(ribcage
-                                                                                                                                      (lambda-var-list
-                                                                                                                                       gen-var
-                                                                                                                                       strip
-                                                                                                                                       strip*
-                                                                                                                                       strip-annotation
-                                                                                                                                       ellipsis?
-                                                                                                                                       chi-void
-                                                                                                                                       chi-local-syntax
-                                                                                                                                       chi-lambda-clause
-                                                                                                                                       parse-begin
-                                                                                                                                       parse-alias
-                                                                                                                                       parse-eval-when
-                                                                                                                                       parse-meta
-                                                                                                                                       parse-define-syntax
-                                                                                                                                       parse-define
-                                                                                                                                       parse-import
-                                                                                                                                       parse-module
-                                                                                                                                       do-import!
-                                                                                                                                       lookup-import-label
-                                                                                                                                       import-mark-delta
-                                                                                                                                       chi-internal
-                                                                                                                                       chi-body
-                                                                                                                                       chi-macro
-                                                                                                                                       chi-set!
-                                                                                                                                       chi-application
-                                                                                                                                       chi-expr
-                                                                                                                                       chi
-                                                                                                                                       chi-sequence
-                                                                                                                                       chi-meta-frob
-                                                                                                                                       chi-frobs
-                                                                                                                                       ct-eval/residualize3
-                                                                                                                                       ct-eval/residualize2
-                                                                                                                                       rt-eval/residualize
-                                                                                                                                       initial-mode-set
-                                                                                                                                       update-mode-set
-                                                                                                                                       do-top-import
-                                                                                                                                       vfor-each
-                                                                                                                                       vmap
-                                                                                                                                       chi-external
-                                                                                                                                       check-defined-ids
-                                                                                                                                       check-module-exports
-                                                                                                                                       id-set-diff
-                                                                                                                                       chi-top-module
-                                                                                                                                       set-frob-meta?!
-                                                                                                                                       set-frob-e!
-                                                                                                                                       frob-meta?
-                                                                                                                                       frob-e
-                                                                                                                                       frob?
-                                                                                                                                       make-frob
-                                                                                                                                       create-module-binding
-                                                                                                                                       set-module-binding-exported!
-                                                                                                                                       set-module-binding-val!
-                                                                                                                                       set-module-binding-imps!
-                                                                                                                                       set-module-binding-label!
-                                                                                                                                       set-module-binding-id!
-                                                                                                                                       set-module-binding-type!
-                                                                                                                                       module-binding-exported
-                                                                                                                                       module-binding-val
-                                                                                                                                       module-binding-imps
-                                                                                                                                       module-binding-label
-                                                                                                                                       module-binding-id
-                                                                                                                                       module-binding-type
-                                                                                                                                       module-binding?
-                                                                                                                                       make-module-binding
-                                                                                                                                       make-resolved-interface
-                                                                                                                                       make-unresolved-interface
-                                                                                                                                       set-interface-token!
-                                                                                                                                       set-interface-exports!
-                                                                                                                                       set-interface-marks!
-                                                                                                                                       interface-token
-                                                                                                                                       interface-exports
-                                                                                                                                       interface-marks
-                                                                                                                                       interface?
-                                                                                                                                       make-interface
-                                                                                                                                       flatten-exports
-                                                                                                                                       chi-top
-                                                                                                                                       chi-top-sequence
-                                                                                                                                       chi-top*
-                                                                                                                                       syntax-type
-                                                                                                                                       chi-when-list
-                                                                                                                                       source-wrap
-                                                                                                                                       wrap
-                                                                                                                                       bound-id-member?
-                                                                                                                                       invalid-ids-error
-                                                                                                                                       distinct-bound-ids?
-                                                                                                                                       valid-bound-ids?
-                                                                                                                                       bound-id=?
-                                                                                                                                       help-bound-id=?
-                                                                                                                                       literal-id=?
-                                                                                                                                       free-id=?
-                                                                                                                                       id-var-name
-                                                                                                                                       id-var-name-loc
-                                                                                                                                       id-var-name&marks
-                                                                                                                                       id-var-name-loc&marks
-                                                                                                                                       top-id-free-var-name
-                                                                                                                                       top-id-bound-var-name
-                                                                                                                                       anon
-                                                                                                                                       diff-marks
-                                                                                                                                       same-marks?
-                                                                                                                                       join-subst
-                                                                                                                                       join-marks
-                                                                                                                                       join-wraps
-                                                                                                                                       smart-append
-                                                                                                                                       resolved-id-var-name
-                                                                                                                                       id->resolved-id
-                                                                                                                                       make-resolved-id
-                                                                                                                                       make-binding-wrap
-                                                                                                                                       store-import-binding
-                                                                                                                                       lookup-import-binding-name
-                                                                                                                                       extend-ribcage-subst!
-                                                                                                                                       extend-ribcage-barrier-help!
-                                                                                                                                       extend-ribcage-barrier!
-                                                                                                                                       import-extend-ribcage!
-                                                                                                                                       extend-ribcage!
-                                                                                                                                       make-empty-ribcage
-                                                                                                                                       barrier-marker
-                                                                                                                                       new-mark
-                                                                                                                                       anti-mark
-                                                                                                                                       the-anti-mark
-                                                                                                                                       set-env-wrap!
-                                                                                                                                       set-env-top-ribcage!
-                                                                                                                                       env-wrap
-                                                                                                                                       env-top-ribcage
-                                                                                                                                       env?
-                                                                                                                                       make-env
-                                                                                                                                       set-import-interface-new-marks!
-                                                                                                                                       set-import-interface-interface!
-                                                                                                                                       import-interface-new-marks
-                                                                                                                                       import-interface-interface
-                                                                                                                                       import-interface?
-                                                                                                                                       make-import-interface
-                                                                                                                                       set-top-ribcage-mutable?!
-                                                                                                                                       set-top-ribcage-key!
-                                                                                                                                       top-ribcage-mutable?
-                                                                                                                                       top-ribcage-key
-                                                                                                                                       top-ribcage?
-                                                                                                                                       make-top-ribcage
-                                                                                                                                       set-ribcage-labels!
-                                                                                                                                       set-ribcage-marks!
-                                                                                                                                       set-ribcage-symnames!
-                                                                                                                                       ribcage-labels
-                                                                                                                                       ribcage-marks
-                                                                                                                                       ribcage-symnames
-                                                                                                                                       ribcage?
-                                                                                                                                       make-ribcage
-                                                                                                                                       gen-labels
-                                                                                                                                       label?
-                                                                                                                                       gen-label
-                                                                                                                                       set-indirect-label!
-                                                                                                                                       get-indirect-label
-                                                                                                                                       indirect-label?
-                                                                                                                                       gen-indirect-label
-                                                                                                                                       anon
-                                                                                                                                       only-top-marked?
-                                                                                                                                       top-marked?
-                                                                                                                                       top-wrap
-                                                                                                                                       empty-wrap
-                                                                                                                                       wrap-subst
-                                                                                                                                       wrap-marks
-                                                                                                                                       make-wrap
-                                                                                                                                       id-sym-name&marks
-                                                                                                                                       id-subst
-                                                                                                                                       id-marks
-                                                                                                                                       id-sym-name
-                                                                                                                                       id?
-                                                                                                                                       nonsymbol-id?
-                                                                                                                                       global-extend
-                                                                                                                                       defer-or-eval-transformer
-                                                                                                                                       make-transformer-binding
-                                                                                                                                       lookup
-                                                                                                                                       lookup*
-                                                                                                                                       displaced-lexical-error
-                                                                                                                                       displaced-lexical?
-                                                                                                                                       extend-var-env*
-                                                                                                                                       extend-env*
-                                                                                                                                       extend-env
-                                                                                                                                       null-env
-                                                                                                                                       binding?
-                                                                                                                                       set-binding-value!
-                                                                                                                                       set-binding-type!
-                                                                                                                                       binding-value
-                                                                                                                                       binding-type
-                                                                                                                                       make-binding
-                                                                                                                                       sanitize-binding
-                                                                                                                                       arg-check
-                                                                                                                                       no-source
-                                                                                                                                       unannotate
-                                                                                                                                       self-evaluating?
-                                                                                                                                       lexical-var?
-                                                                                                                                       build-lexical-var
-                                                                                                                                       build-top-module
-                                                                                                                                       build-body
-                                                                                                                                       build-letrec
-                                                                                                                                       build-sequence
-                                                                                                                                       build-data
-                                                                                                                                       build-primref
-                                                                                                                                       built-lambda?
-                                                                                                                                       build-lambda
-                                                                                                                                       build-revisit-only
-                                                                                                                                       build-visit-only
-                                                                                                                                       build-cte-install
-                                                                                                                                       build-global-definition
-                                                                                                                                       build-global-assignment
-                                                                                                                                       build-global-reference
-                                                                                                                                       build-lexical-assignment
-                                                                                                                                       build-lexical-reference
-                                                                                                                                       build-conditional
-                                                                                                                                       build-application
-                                                                                                                                       generate-id
-                                                                                                                                       put-import-binding
-                                                                                                                                       get-import-binding
-                                                                                                                                       read-only-binding?
-                                                                                                                                       put-global-definition-hook
-                                                                                                                                       get-global-definition-hook
-                                                                                                                                       put-cte-hook
-                                                                                                                                       gensym-hook
-                                                                                                                                       error-hook
-                                                                                                                                       define-top-level-value-hook
-                                                                                                                                       local-eval-hook
-                                                                                                                                       top-level-eval-hook
-                                                                                                                                       annotation?
-                                                                                                                                       set-syntax-object-wrap!
-                                                                                                                                       set-syntax-object-expression!
-                                                                                                                                       syntax-object-wrap
-                                                                                                                                       syntax-object-expression
-                                                                                                                                       syntax-object?
-                                                                                                                                       make-syntax-object
-                                                                                                                                       noexpand
-                                                                                                                                       let-values
-                                                                                                                                       define-structure
-                                                                                                                                       unless
-                                                                                                                                       when)
-                                                                                                                                      ((top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       ("m" top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top)
-                                                                                                                                       (top))
-                                                                                                                                      ("i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"
-                                                                                                                                       "i"))
-                                                                                                                                    #(top-ribcage
-                                                                                                                                      *top*
-                                                                                                                                      #t)))
-                                                                                                                               g847
-                                                                                                                               g848
-                                                                                                                               g952)
-                                                                                                                             (if g844
-                                                                                                                                 (g794
-                                                                                                                                   g952
-                                                                                                                                   g811)
-                                                                                                                                 '#f))])
-                                                                                                                        g950)
-                                                                                                                      ((case-lambda
-                                                                                                                         [(g953)
-                                                                                                                          (if (if g953
-                                                                                                                                  (#%apply
-                                                                                                                                    (case-lambda
-                                                                                                                                      [(g954)
-                                                                                                                                       ((top-level-value
-                                                                                                                                          'identifier?)
-                                                                                                                                         g954)])
-                                                                                                                                    g953)
-                                                                                                                                  '#f)
-                                                                                                                              (#%apply
-                                                                                                                                (case-lambda
-                                                                                                                                  [(g955)
-                                                                                                                                   ((top-level-value
-                                                                                                                                      'values)
-                                                                                                                                     g955
-                                                                                                                                     (#%list
-                                                                                                                                       '#(syntax-object
-                                                                                                                                          $import
-                                                                                                                                          ((top)
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(mid)
-                                                                                                                                              #((top))
-                                                                                                                                              #("i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(m
-                                                                                                                                                exports?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (modspec*
-                                                                                                                                                modspec
-                                                                                                                                                gen-mid
-                                                                                                                                                prefix-drop
-                                                                                                                                                prefix-add
-                                                                                                                                                difference)
-                                                                                                                                              ((top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"
-                                                                                                                                                   "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(r)
-                                                                                                                                              #((top))
-                                                                                                                                              #("i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ()
-                                                                                                                                              ()
-                                                                                                                                              ())
-                                                                                                                                            #(ribcage
-                                                                                                                                              #(orig
-                                                                                                                                                import-only?)
-                                                                                                                                              #((top)
-                                                                                                                                                (top))
-                                                                                                                                              #("i"
-                                                                                                                                                "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              ($import-help
-                                                                                                                                                $module-exports)
-                                                                                                                                              ((top)
-                                                                                                                                                (top))
-                                                                                                                                              ("i" "i"))
-                                                                                                                                            #(ribcage
-                                                                                                                                              (lambda-var-list
-                                                                                                                                               gen-var
-                                                                                                                                               strip
-                                                                                                                                               strip*
-                                                                                                                                               strip-annotation
-                                                                                                                                               ellipsis?
-                                                                                                                                               chi-void
-                                                                                                                                               chi-local-syntax
-                                                                                                                                               chi-lambda-clause
-                                                                                                                                               parse-begin
-                                                                                                                                               parse-alias
-                                                                                                                                               parse-eval-when
-                                                                                                                                               parse-meta
-                                                                                                                                               parse-define-syntax
-                                                                                                                                               parse-define
-                                                                                                                                               parse-import
-                                                                                                                                               parse-module
-                                                                                                                                               do-import!
-                                                                                                                                               lookup-import-label
-                                                                                                                                               import-mark-delta
-                                                                                                                                               chi-internal
-                                                                                                                                               chi-body
-                                                                                                                                               chi-macro
-                                                                                                                                               chi-set!
-                                                                                                                                               chi-application
-                                                                                                                                               chi-expr
-                                                                                                                                               chi
-                                                                                                                                               chi-sequence
-                                                                                                                                               chi-meta-frob
-                                                                                                                                               chi-frobs
-                                                                                                                                               ct-eval/residualize3
-                                                                                                                                               ct-eval/residualize2
-                                                                                                                                               rt-eval/residualize
-                                                                                                                                               initial-mode-set
-                                                                                                                                               update-mode-set
-                                                                                                                                               do-top-import
-                                                                                                                                               vfor-each
-                                                                                                                                               vmap
-                                                                                                                                               chi-external
-                                                                                                                                               check-defined-ids
-                                                                                                                                               check-module-exports
-                                                                                                                                               id-set-diff
-                                                                                                                                               chi-top-module
-                                                                                                                                               set-frob-meta?!
-                                                                                                                                               set-frob-e!
-                                                                                                                                               frob-meta?
-                                                                                                                                               frob-e
-                                                                                                                                               frob?
-                                                                                                                                               make-frob
-                                                                                                                                               create-module-binding
-                                                                                                                                               set-module-binding-exported!
-                                                                                                                                               set-module-binding-val!
-                                                                                                                                               set-module-binding-imps!
-                                                                                                                                               set-module-binding-label!
-                                                                                                                                               set-module-binding-id!
-                                                                                                                                               set-module-binding-type!
-                                                                                                                                               module-binding-exported
-                                                                                                                                               module-binding-val
-                                                                                                                                               module-binding-imps
-                                                                                                                                               module-binding-label
-                                                                                                                                               module-binding-id
-                                                                                                                                               module-binding-type
-                                                                                                                                               module-binding?
-                                                                                                                                               make-module-binding
-                                                                                                                                               make-resolved-interface
-                                                                                                                                               make-unresolved-interface
-                                                                                                                                               set-interface-token!
-                                                                                                                                               set-interface-exports!
-                                                                                                                                               set-interface-marks!
-                                                                                                                                               interface-token
-                                                                                                                                               interface-exports
-                                                                                                                                               interface-marks
-                                                                                                                                               interface?
-                                                                                                                                               make-interface
-                                                                                                                                               flatten-exports
-                                                                                                                                               chi-top
-                                                                                                                                               chi-top-sequence
-                                                                                                                                               chi-top*
-                                                                                                                                               syntax-type
-                                                                                                                                               chi-when-list
-                                                                                                                                               source-wrap
-                                                                                                                                               wrap
-                                                                                                                                               bound-id-member?
-                                                                                                                                               invalid-ids-error
-                                                                                                                                               distinct-bound-ids?
-                                                                                                                                               valid-bound-ids?
-                                                                                                                                               bound-id=?
-                                                                                                                                               help-bound-id=?
-                                                                                                                                               literal-id=?
-                                                                                                                                               free-id=?
-                                                                                                                                               id-var-name
-                                                                                                                                               id-var-name-loc
-                                                                                                                                               id-var-name&marks
-                                                                                                                                               id-var-name-loc&marks
-                                                                                                                                               top-id-free-var-name
-                                                                                                                                               top-id-bound-var-name
-                                                                                                                                               anon
-                                                                                                                                               diff-marks
-                                                                                                                                               same-marks?
-                                                                                                                                               join-subst
-                                                                                                                                               join-marks
-                                                                                                                                               join-wraps
-                                                                                                                                               smart-append
-                                                                                                                                               resolved-id-var-name
-                                                                                                                                               id->resolved-id
-                                                                                                                                               make-resolved-id
-                                                                                                                                               make-binding-wrap
-                                                                                                                                               store-import-binding
-                                                                                                                                               lookup-import-binding-name
-                                                                                                                                               extend-ribcage-subst!
-                                                                                                                                               extend-ribcage-barrier-help!
-                                                                                                                                               extend-ribcage-barrier!
-                                                                                                                                               import-extend-ribcage!
-                                                                                                                                               extend-ribcage!
-                                                                                                                                               make-empty-ribcage
-                                                                                                                                               barrier-marker
-                                                                                                                                               new-mark
-                                                                                                                                               anti-mark
-                                                                                                                                               the-anti-mark
-                                                                                                                                               set-env-wrap!
-                                                                                                                                               set-env-top-ribcage!
-                                                                                                                                               env-wrap
-                                                                                                                                               env-top-ribcage
-                                                                                                                                               env?
-                                                                                                                                               make-env
-                                                                                                                                               set-import-interface-new-marks!
-                                                                                                                                               set-import-interface-interface!
-                                                                                                                                               import-interface-new-marks
-                                                                                                                                               import-interface-interface
-                                                                                                                                               import-interface?
-                                                                                                                                               make-import-interface
-                                                                                                                                               set-top-ribcage-mutable?!
-                                                                                                                                               set-top-ribcage-key!
-                                                                                                                                               top-ribcage-mutable?
-                                                                                                                                               top-ribcage-key
-                                                                                                                                               top-ribcage?
-                                                                                                                                               make-top-ribcage
-                                                                                                                                               set-ribcage-labels!
-                                                                                                                                               set-ribcage-marks!
-                                                                                                                                               set-ribcage-symnames!
-                                                                                                                                               ribcage-labels
-                                                                                                                                               ribcage-marks
-                                                                                                                                               ribcage-symnames
-                                                                                                                                               ribcage?
-                                                                                                                                               make-ribcage
-                                                                                                                                               gen-labels
-                                                                                                                                               label?
-                                                                                                                                               gen-label
-                                                                                                                                               set-indirect-label!
-                                                                                                                                               get-indirect-label
-                                                                                                                                               indirect-label?
-                                                                                                                                               gen-indirect-label
-                                                                                                                                               anon
-                                                                                                                                               only-top-marked?
-                                                                                                                                               top-marked?
-                                                                                                                                               top-wrap
-                                                                                                                                               empty-wrap
-                                                                                                                                               wrap-subst
-                                                                                                                                               wrap-marks
-                                                                                                                                               make-wrap
-                                                                                                                                               id-sym-name&marks
-                                                                                                                                               id-subst
-                                                                                                                                               id-marks
-                                                                                                                                               id-sym-name
-                                                                                                                                               id?
-                                                                                                                                               nonsymbol-id?
-                                                                                                                                               global-extend
-                                                                                                                                               defer-or-eval-transformer
-                                                                                                                                               make-transformer-binding
-                                                                                                                                               lookup
-                                                                                                                                               lookup*
-                                                                                                                                               displaced-lexical-error
-                                                                                                                                               displaced-lexical?
-                                                                                                                                               extend-var-env*
-                                                                                                                                               extend-env*
-                                                                                                                                               extend-env
-                                                                                                                                               null-env
-                                                                                                                                               binding?
-                                                                                                                                               set-binding-value!
-                                                                                                                                               set-binding-type!
-                                                                                                                                               binding-value
-                                                                                                                                               binding-type
-                                                                                                                                               make-binding
-                                                                                                                                               sanitize-binding
-                                                                                                                                               arg-check
-                                                                                                                                               no-source
-                                                                                                                                               unannotate
-                                                                                                                                               self-evaluating?
-                                                                                                                                               lexical-var?
-                                                                                                                                               build-lexical-var
-                                                                                                                                               build-top-module
-                                                                                                                                               build-body
-                                                                                                                                               build-letrec
-                                                                                                                                               build-sequence
-                                                                                                                                               build-data
-                                                                                                                                               build-primref
-                                                                                                                                               built-lambda?
-                                                                                                                                               build-lambda
-                                                                                                                                               build-revisit-only
-                                                                                                                                               build-visit-only
-                                                                                                                                               build-cte-install
-                                                                                                                                               build-global-definition
-                                                                                                                                               build-global-assignment
-                                                                                                                                               build-global-reference
-                                                                                                                                               build-lexical-assignment
-                                                                                                                                               build-lexical-reference
-                                                                                                                                               build-conditional
-                                                                                                                                               build-application
-                                                                                                                                               generate-id
-                                                                                                                                               put-import-binding
-                                                                                                                                               get-import-binding
-                                                                                                                                               read-only-binding?
-                                                                                                                                               put-global-definition-hook
-                                                                                                                                               get-global-definition-hook
-                                                                                                                                               put-cte-hook
-                                                                                                                                               gensym-hook
-                                                                                                                                               error-hook
-                                                                                                                                               define-top-level-value-hook
-                                                                                                                                               local-eval-hook
-                                                                                                                                               top-level-eval-hook
-                                                                                                                                               annotation?
-                                                                                                                                               set-syntax-object-wrap!
-                                                                                                                                               set-syntax-object-expression!
-                                                                                                                                               syntax-object-wrap
-                                                                                                                                               syntax-object-expression
-                                                                                                                                               syntax-object?
-                                                                                                                                               make-syntax-object
-                                                                                                                                               noexpand
-                                                                                                                                               let-values
-                                                                                                                                               define-structure
-                                                                                                                                               unless
-                                                                                                                                               when)
-                                                                                                                                              ((top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               ("m" top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top)
-                                                                                                                                               (top))
-                                                                                                                                              ("i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"
-                                                                                                                                               "i"))
-                                                                                                                                            #(top-ribcage
-                                                                                                                                              *top*
-                                                                                                                                              #t)))
-                                                                                                                                       g847
-                                                                                                                                       g848
-                                                                                                                                       g955)
-                                                                                                                                     (if g844
-                                                                                                                                         (g794
-                                                                                                                                           g955
-                                                                                                                                           g811)
-                                                                                                                                         '#f))])
-                                                                                                                                g953)
-                                                                                                                              ((case-lambda
-                                                                                                                                 [(g956)
-                                                                                                                                  ((top-level-value
-                                                                                                                                     'syntax-error)
-                                                                                                                                    g843
-                                                                                                                                    '"invalid module specifier")])
-                                                                                                                                g849))])
-                                                                                                                        (#%$syntax-dispatch
-                                                                                                                          g849
-                                                                                                                          '(any))))])
-                                                                                                                (#%list
-                                                                                                                  g849)))])
-                                                                                                        (#%$syntax-dispatch
-                                                                                                          g849
-                                                                                                          '(#(free-id
-                                                                                                              #(syntax-object
-                                                                                                                alias
-                                                                                                                ((top)
-                                                                                                                  #(ribcage
-                                                                                                                    #(orig
-                                                                                                                      import-only?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ()
-                                                                                                                    ()
-                                                                                                                    ())
-                                                                                                                  #(ribcage
-                                                                                                                    #(m
-                                                                                                                      exports?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    (modspec*
-                                                                                                                      modspec
-                                                                                                                      gen-mid
-                                                                                                                      prefix-drop
-                                                                                                                      prefix-add
-                                                                                                                      difference)
-                                                                                                                    ((top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top)
-                                                                                                                      (top))
-                                                                                                                    ("i" "i"
-                                                                                                                         "i"
-                                                                                                                         "i"
-                                                                                                                         "i"
-                                                                                                                         "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    #(r)
-                                                                                                                    #((top))
-                                                                                                                    #("i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ()
-                                                                                                                    ()
-                                                                                                                    ())
-                                                                                                                  #(ribcage
-                                                                                                                    #(orig
-                                                                                                                      import-only?)
-                                                                                                                    #((top)
-                                                                                                                      (top))
-                                                                                                                    #("i"
-                                                                                                                      "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    ($import-help
-                                                                                                                      $module-exports)
-                                                                                                                    ((top)
-                                                                                                                      (top))
-                                                                                                                    ("i" "i"))
-                                                                                                                  #(ribcage
-                                                                                                                    (lambda-var-list
-                                                                                                                     gen-var
-                                                                                                                     strip
-                                                                                                                     strip*
-                                                                                                                     strip-annotation
-                                                                                                                     ellipsis?
-                                                                                                                     chi-void
-                                                                                                                     chi-local-syntax
-                                                                                                                     chi-lambda-clause
-                                                                                                                     parse-begin
-                                                                                                                     parse-alias
-                                                                                                                     parse-eval-when
-                                                                                                                     parse-meta
-                                                                                                                     parse-define-syntax
-                                                                                                                     parse-define
-                                                                                                                     parse-import
-                                                                                                                     parse-module
-                                                                                                                     do-import!
-                                                                                                                     lookup-import-label
-                                                                                                                     import-mark-delta
-                                                                                                                     chi-internal
-                                                                                                                     chi-body
-                                                                                                                     chi-macro
-                                                                                                                     chi-set!
-                                                                                                                     chi-application
-                                                                                                                     chi-expr
-                                                                                                                     chi
-                                                                                                                     chi-sequence
-                                                                                                                     chi-meta-frob
-                                                                                                                     chi-frobs
-                                                                                                                     ct-eval/residualize3
-                                                                                                                     ct-eval/residualize2
-                                                                                                                     rt-eval/residualize
-                                                                                                                     initial-mode-set
-                                                                                                                     update-mode-set
-                                                                                                                     do-top-import
-                                                                                                                     vfor-each
-                                                                                                                     vmap
-                                                                                                                     chi-external
-                                                                                                                     check-defined-ids
-                                                                                                                     check-module-exports
-                                                                                                                     id-set-diff
-                                                                                                                     chi-top-module
-                                                                                                                     set-frob-meta?!
-                                                                                                                     set-frob-e!
-                                                                                                                     frob-meta?
-                                                                                                                     frob-e
-                                                                                                                     frob?
-                                                                                                                     make-frob
-                                                                                                                     create-module-binding
-                                                                                                                     set-module-binding-exported!
-                                                                                                                     set-module-binding-val!
-                                                                                                                     set-module-binding-imps!
-                                                                                                                     set-module-binding-label!
-                                                                                                                     set-module-binding-id!
-                                                                                                                     set-module-binding-type!
-                                                                                                                     module-binding-exported
-                                                                                                                     module-binding-val
-                                                                                                                     module-binding-imps
-                                                                                                                     module-binding-label
-                                                                                                                     module-binding-id
-                                                                                                                     module-binding-type
-                                                                                                                     module-binding?
-                                                                                                                     make-module-binding
-                                                                                                                     make-resolved-interface
-                                                                                                                     make-unresolved-interface
-                                                                                                                     set-interface-token!
-                                                                                                                     set-interface-exports!
-                                                                                                                     set-interface-marks!
-                                                                                                                     interface-token
-                                                                                                                     interface-exports
-                                                                                                                     interface-marks
-                                                                                                                     interface?
-                                                                                                                     make-interface
-                                                                                                                     flatten-exports
-                                                                                                                     chi-top
-                                                                                                                     chi-top-sequence
-                                                                                                                     chi-top*
-                                                                                                                     syntax-type
-                                                                                                                     chi-when-list
-                                                                                                                     source-wrap
-                                                                                                                     wrap
-                                                                                                                     bound-id-member?
-                                                                                                                     invalid-ids-error
-                                                                                                                     distinct-bound-ids?
-                                                                                                                     valid-bound-ids?
-                                                                                                                     bound-id=?
-                                                                                                                     help-bound-id=?
-                                                                                                                     literal-id=?
-                                                                                                                     free-id=?
-                                                                                                                     id-var-name
-                                                                                                                     id-var-name-loc
-                                                                                                                     id-var-name&marks
-                                                                                                                     id-var-name-loc&marks
-                                                                                                                     top-id-free-var-name
-                                                                                                                     top-id-bound-var-name
-                                                                                                                     anon
-                                                                                                                     diff-marks
-                                                                                                                     same-marks?
-                                                                                                                     join-subst
-                                                                                                                     join-marks
-                                                                                                                     join-wraps
-                                                                                                                     smart-append
-                                                                                                                     resolved-id-var-name
-                                                                                                                     id->resolved-id
-                                                                                                                     make-resolved-id
-                                                                                                                     make-binding-wrap
-                                                                                                                     store-import-binding
-                                                                                                                     lookup-import-binding-name
-                                                                                                                     extend-ribcage-subst!
-                                                                                                                     extend-ribcage-barrier-help!
-                                                                                                                     extend-ribcage-barrier!
-                                                                                                                     import-extend-ribcage!
-                                                                                                                     extend-ribcage!
-                                                                                                                     make-empty-ribcage
-                                                                                                                     barrier-marker
-                                                                                                                     new-mark
-                                                                                                                     anti-mark
-                                                                                                                     the-anti-mark
-                                                                                                                     set-env-wrap!
-                                                                                                                     set-env-top-ribcage!
-                                                                                                                     env-wrap
-                                                                                                                     env-top-ribcage
-                                                                                                                     env?
-                                                                                                                     make-env
-                                                                                                                     set-import-interface-new-marks!
-                                                                                                                     set-import-interface-interface!
-                                                                                                                     import-interface-new-marks
-                                                                                                                     import-interface-interface
-                                                                                                                     import-interface?
-                                                                                                                     make-import-interface
-                                                                                                                     set-top-ribcage-mutable?!
-                                                                                                                     set-top-ribcage-key!
-                                                                                                                     top-ribcage-mutable?
-                                                                                                                     top-ribcage-key
-                                                                                                                     top-ribcage?
-                                                                                                                     make-top-ribcage
-                                                                                                                     set-ribcage-labels!
-                                                                                                                     set-ribcage-marks!
-                                                                                                                     set-ribcage-symnames!
-                                                                                                                     ribcage-labels
-                                                                                                                     ribcage-marks
-                                                                                                                     ribcage-symnames
-                                                                                                                     ribcage?
-                                                                                                                     make-ribcage
-                                                                                                                     gen-labels
-                                                                                                                     label?
-                                                                                                                     gen-label
-                                                                                                                     set-indirect-label!
-                                                                                                                     get-indirect-label
-                                                                                                                     indirect-label?
-                                                                                                                     gen-indirect-label
-                                                                                                                     anon
-                                                                                                                     only-top-marked?
-                                                                                                                     top-marked?
-                                                                                                                     top-wrap
-                                                                                                                     empty-wrap
-                                                                                                                     wrap-subst
-                                                                                                                     wrap-marks
-                                                                                                                     make-wrap
-                                                                                                                     id-sym-name&marks
-                                                                                                                     id-subst
-                                                                                                                     id-marks
-                                                                                                                     id-sym-name
-                                                                                                                     id?
-                                                                                                                     nonsymbol-id?
-                                                                                                                     global-extend
-                                                                                                                     defer-or-eval-transformer
-                                                                                                                     make-transformer-binding
-                                                                                                                     lookup
-                                                                                                                     lookup*
-                                                                                                                     displaced-lexical-error
-                                                                                                                     displaced-lexical?
-                                                                                                                     extend-var-env*
-                                                                                                                     extend-env*
-                                                                                                                     extend-env
-                                                                                                                     null-env
-                                                                                                                     binding?
-                                                                                                                     set-binding-value!
-                                                                                                                     set-binding-type!
-                                                                                                                     binding-value
-                                                                                                                     binding-type
-                                                                                                                     make-binding
-                                                                                                                     sanitize-binding
-                                                                                                                     arg-check
-                                                                                                                     no-source
-                                                                                                                     unannotate
-                                                                                                                     self-evaluating?
-                                                                                                                     lexical-var?
-                                                                                                                     build-lexical-var
-                                                                                                                     build-top-module
-                                                                                                                     build-body
-                                                                                                                     build-letrec
-                                                                                                                     build-sequence
-                                                                                                                     build-data
-                                                                                                                     build-primref
-                                                                                                                     built-lambda?
-                                                                                                                     build-lambda
-                                                                                                                     build-revisit-only
-                                                                                                                     build-visit-only
-                                                                                                                     build-cte-install
-                                                                                                                     build-global-definition
-                                                                                                                     build-global-assignment
-                                                                                                                     build-global-reference
-                                                                                                                     build-lexical-assignment
-                                                                                                                     build-lexical-reference
-                                                                                                                     build-conditional
-                                                                                                                     build-application
-                                                                                                                     generate-id
-                                                                                                                     put-import-binding
-                                                                                                                     get-import-binding
-                                                                                                                     read-only-binding?
-                                                                                                                     put-global-definition-hook
-                                                                                                                     get-global-definition-hook
-                                                                                                                     put-cte-hook
-                                                                                                                     gensym-hook
-                                                                                                                     error-hook
-                                                                                                                     define-top-level-value-hook
-                                                                                                                     local-eval-hook
-                                                                                                                     top-level-eval-hook
-                                                                                                                     annotation?
-                                                                                                                     set-syntax-object-wrap!
-                                                                                                                     set-syntax-object-expression!
-                                                                                                                     syntax-object-wrap
-                                                                                                                     syntax-object-expression
-                                                                                                                     syntax-object?
-                                                                                                                     make-syntax-object
-                                                                                                                     noexpand
-                                                                                                                     let-values
-                                                                                                                     define-structure
-                                                                                                                     unless
-                                                                                                                     when)
-                                                                                                                    ((top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     ("m" top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     ("m" top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top)
-                                                                                                                     (top))
-                                                                                                                    ("i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"
-                                                                                                                     "i"))
-                                                                                                                  #(top-ribcage
-                                                                                                                    *top*
-                                                                                                                    #t))))
-                                                                                                             any
-                                                                                                             .
-                                                                                                             #(each
-                                                                                                               (any any))))))])
-                                                                                                (#%$syntax-dispatch
-                                                                                                  g849
-                                                                                                  '(#(free-id
-                                                                                                      #(syntax-object
-                                                                                                        rename
-                                                                                                        ((top)
-                                                                                                          #(ribcage
-                                                                                                            #(orig
-                                                                                                              import-only?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            ()
-                                                                                                            ()
-                                                                                                            ())
-                                                                                                          #(ribcage
-                                                                                                            #(m
-                                                                                                              exports?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            (modspec*
-                                                                                                              modspec
-                                                                                                              gen-mid
-                                                                                                              prefix-drop
-                                                                                                              prefix-add
-                                                                                                              difference)
-                                                                                                            ((top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top)
-                                                                                                              (top))
-                                                                                                            ("i" "i"
-                                                                                                                 "i"
-                                                                                                                 "i"
-                                                                                                                 "i"
-                                                                                                                 "i"))
-                                                                                                          #(ribcage
-                                                                                                            #(r)
-                                                                                                            #((top))
-                                                                                                            #("i"))
-                                                                                                          #(ribcage
-                                                                                                            ()
-                                                                                                            ()
-                                                                                                            ())
-                                                                                                          #(ribcage
-                                                                                                            #(orig
-                                                                                                              import-only?)
-                                                                                                            #((top)
-                                                                                                              (top))
-                                                                                                            #("i"
-                                                                                                              "i"))
-                                                                                                          #(ribcage
-                                                                                                            ($import-help
-                                                                                                              $module-exports)
-                                                                                                            ((top)
-                                                                                                              (top))
-                                                                                                            ("i" "i"))
-                                                                                                          #(ribcage
-                                                                                                            (lambda-var-list
-                                                                                                             gen-var
-                                                                                                             strip
-                                                                                                             strip*
-                                                                                                             strip-annotation
-                                                                                                             ellipsis?
-                                                                                                             chi-void
-                                                                                                             chi-local-syntax
-                                                                                                             chi-lambda-clause
-                                                                                                             parse-begin
-                                                                                                             parse-alias
-                                                                                                             parse-eval-when
-                                                                                                             parse-meta
-                                                                                                             parse-define-syntax
-                                                                                                             parse-define
-                                                                                                             parse-import
-                                                                                                             parse-module
-                                                                                                             do-import!
-                                                                                                             lookup-import-label
-                                                                                                             import-mark-delta
-                                                                                                             chi-internal
-                                                                                                             chi-body
-                                                                                                             chi-macro
-                                                                                                             chi-set!
-                                                                                                             chi-application
-                                                                                                             chi-expr
-                                                                                                             chi
-                                                                                                             chi-sequence
-                                                                                                             chi-meta-frob
-                                                                                                             chi-frobs
-                                                                                                             ct-eval/residualize3
-                                                                                                             ct-eval/residualize2
-                                                                                                             rt-eval/residualize
-                                                                                                             initial-mode-set
-                                                                                                             update-mode-set
-                                                                                                             do-top-import
-                                                                                                             vfor-each
-                                                                                                             vmap
-                                                                                                             chi-external
-                                                                                                             check-defined-ids
-                                                                                                             check-module-exports
-                                                                                                             id-set-diff
-                                                                                                             chi-top-module
-                                                                                                             set-frob-meta?!
-                                                                                                             set-frob-e!
-                                                                                                             frob-meta?
-                                                                                                             frob-e
-                                                                                                             frob?
-                                                                                                             make-frob
-                                                                                                             create-module-binding
-                                                                                                             set-module-binding-exported!
-                                                                                                             set-module-binding-val!
-                                                                                                             set-module-binding-imps!
-                                                                                                             set-module-binding-label!
-                                                                                                             set-module-binding-id!
-                                                                                                             set-module-binding-type!
-                                                                                                             module-binding-exported
-                                                                                                             module-binding-val
-                                                                                                             module-binding-imps
-                                                                                                             module-binding-label
-                                                                                                             module-binding-id
-                                                                                                             module-binding-type
-                                                                                                             module-binding?
-                                                                                                             make-module-binding
-                                                                                                             make-resolved-interface
-                                                                                                             make-unresolved-interface
-                                                                                                             set-interface-token!
-                                                                                                             set-interface-exports!
-                                                                                                             set-interface-marks!
-                                                                                                             interface-token
-                                                                                                             interface-exports
-                                                                                                             interface-marks
-                                                                                                             interface?
-                                                                                                             make-interface
-                                                                                                             flatten-exports
-                                                                                                             chi-top
-                                                                                                             chi-top-sequence
-                                                                                                             chi-top*
-                                                                                                             syntax-type
-                                                                                                             chi-when-list
-                                                                                                             source-wrap
-                                                                                                             wrap
-                                                                                                             bound-id-member?
-                                                                                                             invalid-ids-error
-                                                                                                             distinct-bound-ids?
-                                                                                                             valid-bound-ids?
-                                                                                                             bound-id=?
-                                                                                                             help-bound-id=?
-                                                                                                             literal-id=?
-                                                                                                             free-id=?
-                                                                                                             id-var-name
-                                                                                                             id-var-name-loc
-                                                                                                             id-var-name&marks
-                                                                                                             id-var-name-loc&marks
-                                                                                                             top-id-free-var-name
-                                                                                                             top-id-bound-var-name
-                                                                                                             anon
-                                                                                                             diff-marks
-                                                                                                             same-marks?
-                                                                                                             join-subst
-                                                                                                             join-marks
-                                                                                                             join-wraps
-                                                                                                             smart-append
-                                                                                                             resolved-id-var-name
-                                                                                                             id->resolved-id
-                                                                                                             make-resolved-id
-                                                                                                             make-binding-wrap
-                                                                                                             store-import-binding
-                                                                                                             lookup-import-binding-name
-                                                                                                             extend-ribcage-subst!
-                                                                                                             extend-ribcage-barrier-help!
-                                                                                                             extend-ribcage-barrier!
-                                                                                                             import-extend-ribcage!
-                                                                                                             extend-ribcage!
-                                                                                                             make-empty-ribcage
-                                                                                                             barrier-marker
-                                                                                                             new-mark
-                                                                                                             anti-mark
-                                                                                                             the-anti-mark
-                                                                                                             set-env-wrap!
-                                                                                                             set-env-top-ribcage!
-                                                                                                             env-wrap
-                                                                                                             env-top-ribcage
-                                                                                                             env?
-                                                                                                             make-env
-                                                                                                             set-import-interface-new-marks!
-                                                                                                             set-import-interface-interface!
-                                                                                                             import-interface-new-marks
-                                                                                                             import-interface-interface
-                                                                                                             import-interface?
-                                                                                                             make-import-interface
-                                                                                                             set-top-ribcage-mutable?!
-                                                                                                             set-top-ribcage-key!
-                                                                                                             top-ribcage-mutable?
-                                                                                                             top-ribcage-key
-                                                                                                             top-ribcage?
-                                                                                                             make-top-ribcage
-                                                                                                             set-ribcage-labels!
-                                                                                                             set-ribcage-marks!
-                                                                                                             set-ribcage-symnames!
-                                                                                                             ribcage-labels
-                                                                                                             ribcage-marks
-                                                                                                             ribcage-symnames
-                                                                                                             ribcage?
-                                                                                                             make-ribcage
-                                                                                                             gen-labels
-                                                                                                             label?
-                                                                                                             gen-label
-                                                                                                             set-indirect-label!
-                                                                                                             get-indirect-label
-                                                                                                             indirect-label?
-                                                                                                             gen-indirect-label
-                                                                                                             anon
-                                                                                                             only-top-marked?
-                                                                                                             top-marked?
-                                                                                                             top-wrap
-                                                                                                             empty-wrap
-                                                                                                             wrap-subst
-                                                                                                             wrap-marks
-                                                                                                             make-wrap
-                                                                                                             id-sym-name&marks
-                                                                                                             id-subst
-                                                                                                             id-marks
-                                                                                                             id-sym-name
-                                                                                                             id?
-                                                                                                             nonsymbol-id?
-                                                                                                             global-extend
-                                                                                                             defer-or-eval-transformer
-                                                                                                             make-transformer-binding
-                                                                                                             lookup
-                                                                                                             lookup*
-                                                                                                             displaced-lexical-error
-                                                                                                             displaced-lexical?
-                                                                                                             extend-var-env*
-                                                                                                             extend-env*
-                                                                                                             extend-env
-                                                                                                             null-env
-                                                                                                             binding?
-                                                                                                             set-binding-value!
-                                                                                                             set-binding-type!
-                                                                                                             binding-value
-                                                                                                             binding-type
-                                                                                                             make-binding
-                                                                                                             sanitize-binding
-                                                                                                             arg-check
-                                                                                                             no-source
-                                                                                                             unannotate
-                                                                                                             self-evaluating?
-                                                                                                             lexical-var?
-                                                                                                             build-lexical-var
-                                                                                                             build-top-module
-                                                                                                             build-body
-                                                                                                             build-letrec
-                                                                                                             build-sequence
-                                                                                                             build-data
-                                                                                                             build-primref
-                                                                                                             built-lambda?
-                                                                                                             build-lambda
-                                                                                                             build-revisit-only
-                                                                                                             build-visit-only
-                                                                                                             build-cte-install
-                                                                                                             build-global-definition
-                                                                                                             build-global-assignment
-                                                                                                             build-global-reference
-                                                                                                             build-lexical-assignment
-                                                                                                             build-lexical-reference
-                                                                                                             build-conditional
-                                                                                                             build-application
-                                                                                                             generate-id
-                                                                                                             put-import-binding
-                                                                                                             get-import-binding
-                                                                                                             read-only-binding?
-                                                                                                             put-global-definition-hook
-                                                                                                             get-global-definition-hook
-                                                                                                             put-cte-hook
-                                                                                                             gensym-hook
-                                                                                                             error-hook
-                                                                                                             define-top-level-value-hook
-                                                                                                             local-eval-hook
-                                                                                                             top-level-eval-hook
-                                                                                                             annotation?
-                                                                                                             set-syntax-object-wrap!
-                                                                                                             set-syntax-object-expression!
-                                                                                                             syntax-object-wrap
-                                                                                                             syntax-object-expression
-                                                                                                             syntax-object?
-                                                                                                             make-syntax-object
-                                                                                                             noexpand
-                                                                                                             let-values
-                                                                                                             define-structure
-                                                                                                             unless
-                                                                                                             when)
-                                                                                                            ((top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             ("m" top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             ("m" top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top)
-                                                                                                             (top))
-                                                                                                            ("i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"
-                                                                                                             "i"))
-                                                                                                          #(top-ribcage
-                                                                                                            *top*
-                                                                                                            #t))))
-                                                                                                     any
-                                                                                                     .
-                                                                                                     #(each
-                                                                                                       (any any))))))])
-                                                                                        (#%$syntax-dispatch
-                                                                                          g849
-                                                                                          '(#(free-id
-                                                                                              #(syntax-object
-                                                                                                drop-prefix
-                                                                                                ((top)
-                                                                                                  #(ribcage
-                                                                                                    #(orig
-                                                                                                      import-only?)
-                                                                                                    #((top)
-                                                                                                      (top))
-                                                                                                    #("i"
-                                                                                                      "i"))
-                                                                                                  #(ribcage
-                                                                                                    ()
-                                                                                                    ()
-                                                                                                    ())
-                                                                                                  #(ribcage
-                                                                                                    #(m
-                                                                                                      exports?)
-                                                                                                    #((top)
-                                                                                                      (top))
-                                                                                                    #("i"
-                                                                                                      "i"))
-                                                                                                  #(ribcage
-                                                                                                    (modspec*
-                                                                                                      modspec
-                                                                                                      gen-mid
-                                                                                                      prefix-drop
-                                                                                                      prefix-add
-                                                                                                      difference)
-                                                                                                    ((top)
-                                                                                                      (top)
-                                                                                                      (top)
-                                                                                                      (top)
-                                                                                                      (top)
-                                                                                                      (top))
-                                                                                                    ("i" "i"
-                                                                                                         "i"
-                                                                                                         "i"
-                                                                                                         "i"
-                                                                                                         "i"))
-                                                                                                  #(ribcage
-                                                                                                    #(r)
-                                                                                                    #((top))
-                                                                                                    #("i"))
-                                                                                                  #(ribcage
-                                                                                                    ()
-                                                                                                    ()
-                                                                                                    ())
-                                                                                                  #(ribcage
-                                                                                                    #(orig
-                                                                                                      import-only?)
-                                                                                                    #((top)
-                                                                                                      (top))
-                                                                                                    #("i"
-                                                                                                      "i"))
-                                                                                                  #(ribcage
-                                                                                                    ($import-help
-                                                                                                      $module-exports)
-                                                                                                    ((top)
-                                                                                                      (top))
-                                                                                                    ("i" "i"))
-                                                                                                  #(ribcage
-                                                                                                    (lambda-var-list
-                                                                                                     gen-var
-                                                                                                     strip
-                                                                                                     strip*
-                                                                                                     strip-annotation
-                                                                                                     ellipsis?
-                                                                                                     chi-void
-                                                                                                     chi-local-syntax
-                                                                                                     chi-lambda-clause
-                                                                                                     parse-begin
-                                                                                                     parse-alias
-                                                                                                     parse-eval-when
-                                                                                                     parse-meta
-                                                                                                     parse-define-syntax
-                                                                                                     parse-define
-                                                                                                     parse-import
-                                                                                                     parse-module
-                                                                                                     do-import!
-                                                                                                     lookup-import-label
-                                                                                                     import-mark-delta
-                                                                                                     chi-internal
-                                                                                                     chi-body
-                                                                                                     chi-macro
-                                                                                                     chi-set!
-                                                                                                     chi-application
-                                                                                                     chi-expr
-                                                                                                     chi
-                                                                                                     chi-sequence
-                                                                                                     chi-meta-frob
-                                                                                                     chi-frobs
-                                                                                                     ct-eval/residualize3
-                                                                                                     ct-eval/residualize2
-                                                                                                     rt-eval/residualize
-                                                                                                     initial-mode-set
-                                                                                                     update-mode-set
-                                                                                                     do-top-import
-                                                                                                     vfor-each
-                                                                                                     vmap
-                                                                                                     chi-external
-                                                                                                     check-defined-ids
-                                                                                                     check-module-exports
-                                                                                                     id-set-diff
-                                                                                                     chi-top-module
-                                                                                                     set-frob-meta?!
-                                                                                                     set-frob-e!
-                                                                                                     frob-meta?
-                                                                                                     frob-e
-                                                                                                     frob?
-                                                                                                     make-frob
-                                                                                                     create-module-binding
-                                                                                                     set-module-binding-exported!
-                                                                                                     set-module-binding-val!
-                                                                                                     set-module-binding-imps!
-                                                                                                     set-module-binding-label!
-                                                                                                     set-module-binding-id!
-                                                                                                     set-module-binding-type!
-                                                                                                     module-binding-exported
-                                                                                                     module-binding-val
-                                                                                                     module-binding-imps
-                                                                                                     module-binding-label
-                                                                                                     module-binding-id
-                                                                                                     module-binding-type
-                                                                                                     module-binding?
-                                                                                                     make-module-binding
-                                                                                                     make-resolved-interface
-                                                                                                     make-unresolved-interface
-                                                                                                     set-interface-token!
-                                                                                                     set-interface-exports!
-                                                                                                     set-interface-marks!
-                                                                                                     interface-token
-                                                                                                     interface-exports
-                                                                                                     interface-marks
-                                                                                                     interface?
-                                                                                                     make-interface
-                                                                                                     flatten-exports
-                                                                                                     chi-top
-                                                                                                     chi-top-sequence
-                                                                                                     chi-top*
-                                                                                                     syntax-type
-                                                                                                     chi-when-list
-                                                                                                     source-wrap
-                                                                                                     wrap
-                                                                                                     bound-id-member?
-                                                                                                     invalid-ids-error
-                                                                                                     distinct-bound-ids?
-                                                                                                     valid-bound-ids?
-                                                                                                     bound-id=?
-                                                                                                     help-bound-id=?
-                                                                                                     literal-id=?
-                                                                                                     free-id=?
-                                                                                                     id-var-name
-                                                                                                     id-var-name-loc
-                                                                                                     id-var-name&marks
-                                                                                                     id-var-name-loc&marks
-                                                                                                     top-id-free-var-name
-                                                                                                     top-id-bound-var-name
-                                                                                                     anon
-                                                                                                     diff-marks
-                                                                                                     same-marks?
-                                                                                                     join-subst
-                                                                                                     join-marks
-                                                                                                     join-wraps
-                                                                                                     smart-append
-                                                                                                     resolved-id-var-name
-                                                                                                     id->resolved-id
-                                                                                                     make-resolved-id
-                                                                                                     make-binding-wrap
-                                                                                                     store-import-binding
-                                                                                                     lookup-import-binding-name
-                                                                                                     extend-ribcage-subst!
-                                                                                                     extend-ribcage-barrier-help!
-                                                                                                     extend-ribcage-barrier!
-                                                                                                     import-extend-ribcage!
-                                                                                                     extend-ribcage!
-                                                                                                     make-empty-ribcage
-                                                                                                     barrier-marker
-                                                                                                     new-mark
-                                                                                                     anti-mark
-                                                                                                     the-anti-mark
-                                                                                                     set-env-wrap!
-                                                                                                     set-env-top-ribcage!
-                                                                                                     env-wrap
-                                                                                                     env-top-ribcage
-                                                                                                     env?
-                                                                                                     make-env
-                                                                                                     set-import-interface-new-marks!
-                                                                                                     set-import-interface-interface!
-                                                                                                     import-interface-new-marks
-                                                                                                     import-interface-interface
-                                                                                                     import-interface?
-                                                                                                     make-import-interface
-                                                                                                     set-top-ribcage-mutable?!
-                                                                                                     set-top-ribcage-key!
-                                                                                                     top-ribcage-mutable?
-                                                                                                     top-ribcage-key
-                                                                                                     top-ribcage?
-                                                                                                     make-top-ribcage
-                                                                                                     set-ribcage-labels!
-                                                                                                     set-ribcage-marks!
-                                                                                                     set-ribcage-symnames!
-                                                                                                     ribcage-labels
-                                                                                                     ribcage-marks
-                                                                                                     ribcage-symnames
-                                                                                                     ribcage?
-                                                                                                     make-ribcage
-                                                                                                     gen-labels
-                                                                                                     label?
-                                                                                                     gen-label
-                                                                                                     set-indirect-label!
-                                                                                                     get-indirect-label
-                                                                                                     indirect-label?
-                                                                                                     gen-indirect-label
-                                                                                                     anon
-                                                                                                     only-top-marked?
-                                                                                                     top-marked?
-                                                                                                     top-wrap
-                                                                                                     empty-wrap
-                                                                                                     wrap-subst
-                                                                                                     wrap-marks
-                                                                                                     make-wrap
-                                                                                                     id-sym-name&marks
-                                                                                                     id-subst
-                                                                                                     id-marks
-                                                                                                     id-sym-name
-                                                                                                     id?
-                                                                                                     nonsymbol-id?
-                                                                                                     global-extend
-                                                                                                     defer-or-eval-transformer
-                                                                                                     make-transformer-binding
-                                                                                                     lookup
-                                                                                                     lookup*
-                                                                                                     displaced-lexical-error
-                                                                                                     displaced-lexical?
-                                                                                                     extend-var-env*
-                                                                                                     extend-env*
-                                                                                                     extend-env
-                                                                                                     null-env
-                                                                                                     binding?
-                                                                                                     set-binding-value!
-                                                                                                     set-binding-type!
-                                                                                                     binding-value
-                                                                                                     binding-type
-                                                                                                     make-binding
-                                                                                                     sanitize-binding
-                                                                                                     arg-check
-                                                                                                     no-source
-                                                                                                     unannotate
-                                                                                                     self-evaluating?
-                                                                                                     lexical-var?
-                                                                                                     build-lexical-var
-                                                                                                     build-top-module
-                                                                                                     build-body
-                                                                                                     build-letrec
-                                                                                                     build-sequence
-                                                                                                     build-data
-                                                                                                     build-primref
-                                                                                                     built-lambda?
-                                                                                                     build-lambda
-                                                                                                     build-revisit-only
-                                                                                                     build-visit-only
-                                                                                                     build-cte-install
-                                                                                                     build-global-definition
-                                                                                                     build-global-assignment
-                                                                                                     build-global-reference
-                                                                                                     build-lexical-assignment
-                                                                                                     build-lexical-reference
-                                                                                                     build-conditional
-                                                                                                     build-application
-                                                                                                     generate-id
-                                                                                                     put-import-binding
-                                                                                                     get-import-binding
-                                                                                                     read-only-binding?
-                                                                                                     put-global-definition-hook
-                                                                                                     get-global-definition-hook
-                                                                                                     put-cte-hook
-                                                                                                     gensym-hook
-                                                                                                     error-hook
-                                                                                                     define-top-level-value-hook
-                                                                                                     local-eval-hook
-                                                                                                     top-level-eval-hook
-                                                                                                     annotation?
-                                                                                                     set-syntax-object-wrap!
-                                                                                                     set-syntax-object-expression!
-                                                                                                     syntax-object-wrap
-                                                                                                     syntax-object-expression
-                                                                                                     syntax-object?
-                                                                                                     make-syntax-object
-                                                                                                     noexpand
-                                                                                                     let-values
-                                                                                                     define-structure
-                                                                                                     unless
-                                                                                                     when)
-                                                                                                    ((top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     ("m" top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     ("m" top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top)
-                                                                                                     (top))
-                                                                                                    ("i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"
-                                                                                                     "i"))
-                                                                                                  #(top-ribcage
-                                                                                                    *top*
-                                                                                                    #t))))
-                                                                                             any
-                                                                                             any))))])
-                                                                                (#%$syntax-dispatch
-                                                                                  g849
-                                                                                  '(#(free-id
-                                                                                      #(syntax-object
-                                                                                        add-prefix
-                                                                                        ((top)
-                                                                                          #(ribcage
-                                                                                            #(orig
-                                                                                              import-only?)
-                                                                                            #((top)
-                                                                                              (top))
-                                                                                            #("i"
-                                                                                              "i"))
-                                                                                          #(ribcage
-                                                                                            ()
-                                                                                            ()
-                                                                                            ())
-                                                                                          #(ribcage
-                                                                                            #(m
-                                                                                              exports?)
-                                                                                            #((top)
-                                                                                              (top))
-                                                                                            #("i"
-                                                                                              "i"))
-                                                                                          #(ribcage
-                                                                                            (modspec*
-                                                                                              modspec
-                                                                                              gen-mid
-                                                                                              prefix-drop
-                                                                                              prefix-add
-                                                                                              difference)
-                                                                                            ((top)
-                                                                                              (top)
-                                                                                              (top)
-                                                                                              (top)
-                                                                                              (top)
-                                                                                              (top))
-                                                                                            ("i" "i"
-                                                                                                 "i"
-                                                                                                 "i"
-                                                                                                 "i"
-                                                                                                 "i"))
-                                                                                          #(ribcage
-                                                                                            #(r)
-                                                                                            #((top))
-                                                                                            #("i"))
-                                                                                          #(ribcage
-                                                                                            ()
-                                                                                            ()
-                                                                                            ())
-                                                                                          #(ribcage
-                                                                                            #(orig
-                                                                                              import-only?)
-                                                                                            #((top)
-                                                                                              (top))
-                                                                                            #("i"
-                                                                                              "i"))
-                                                                                          #(ribcage
-                                                                                            ($import-help
-                                                                                              $module-exports)
-                                                                                            ((top)
-                                                                                              (top))
-                                                                                            ("i" "i"))
-                                                                                          #(ribcage
-                                                                                            (lambda-var-list
-                                                                                             gen-var
-                                                                                             strip
-                                                                                             strip*
-                                                                                             strip-annotation
-                                                                                             ellipsis?
-                                                                                             chi-void
-                                                                                             chi-local-syntax
-                                                                                             chi-lambda-clause
-                                                                                             parse-begin
-                                                                                             parse-alias
-                                                                                             parse-eval-when
-                                                                                             parse-meta
-                                                                                             parse-define-syntax
-                                                                                             parse-define
-                                                                                             parse-import
-                                                                                             parse-module
-                                                                                             do-import!
-                                                                                             lookup-import-label
-                                                                                             import-mark-delta
-                                                                                             chi-internal
-                                                                                             chi-body
-                                                                                             chi-macro
-                                                                                             chi-set!
-                                                                                             chi-application
-                                                                                             chi-expr
-                                                                                             chi
-                                                                                             chi-sequence
-                                                                                             chi-meta-frob
-                                                                                             chi-frobs
-                                                                                             ct-eval/residualize3
-                                                                                             ct-eval/residualize2
-                                                                                             rt-eval/residualize
-                                                                                             initial-mode-set
-                                                                                             update-mode-set
-                                                                                             do-top-import
-                                                                                             vfor-each
-                                                                                             vmap
-                                                                                             chi-external
-                                                                                             check-defined-ids
-                                                                                             check-module-exports
-                                                                                             id-set-diff
-                                                                                             chi-top-module
-                                                                                             set-frob-meta?!
-                                                                                             set-frob-e!
-                                                                                             frob-meta?
-                                                                                             frob-e
-                                                                                             frob?
-                                                                                             make-frob
-                                                                                             create-module-binding
-                                                                                             set-module-binding-exported!
-                                                                                             set-module-binding-val!
-                                                                                             set-module-binding-imps!
-                                                                                             set-module-binding-label!
-                                                                                             set-module-binding-id!
-                                                                                             set-module-binding-type!
-                                                                                             module-binding-exported
-                                                                                             module-binding-val
-                                                                                             module-binding-imps
-                                                                                             module-binding-label
-                                                                                             module-binding-id
-                                                                                             module-binding-type
-                                                                                             module-binding?
-                                                                                             make-module-binding
-                                                                                             make-resolved-interface
-                                                                                             make-unresolved-interface
-                                                                                             set-interface-token!
-                                                                                             set-interface-exports!
-                                                                                             set-interface-marks!
-                                                                                             interface-token
-                                                                                             interface-exports
-                                                                                             interface-marks
-                                                                                             interface?
-                                                                                             make-interface
-                                                                                             flatten-exports
-                                                                                             chi-top
-                                                                                             chi-top-sequence
-                                                                                             chi-top*
-                                                                                             syntax-type
-                                                                                             chi-when-list
-                                                                                             source-wrap
-                                                                                             wrap
-                                                                                             bound-id-member?
-                                                                                             invalid-ids-error
-                                                                                             distinct-bound-ids?
-                                                                                             valid-bound-ids?
-                                                                                             bound-id=?
-                                                                                             help-bound-id=?
-                                                                                             literal-id=?
-                                                                                             free-id=?
-                                                                                             id-var-name
-                                                                                             id-var-name-loc
-                                                                                             id-var-name&marks
-                                                                                             id-var-name-loc&marks
-                                                                                             top-id-free-var-name
-                                                                                             top-id-bound-var-name
-                                                                                             anon
-                                                                                             diff-marks
-                                                                                             same-marks?
-                                                                                             join-subst
-                                                                                             join-marks
-                                                                                             join-wraps
-                                                                                             smart-append
-                                                                                             resolved-id-var-name
-                                                                                             id->resolved-id
-                                                                                             make-resolved-id
-                                                                                             make-binding-wrap
-                                                                                             store-import-binding
-                                                                                             lookup-import-binding-name
-                                                                                             extend-ribcage-subst!
-                                                                                             extend-ribcage-barrier-help!
-                                                                                             extend-ribcage-barrier!
-                                                                                             import-extend-ribcage!
-                                                                                             extend-ribcage!
-                                                                                             make-empty-ribcage
-                                                                                             barrier-marker
-                                                                                             new-mark
-                                                                                             anti-mark
-                                                                                             the-anti-mark
-                                                                                             set-env-wrap!
-                                                                                             set-env-top-ribcage!
-                                                                                             env-wrap
-                                                                                             env-top-ribcage
-                                                                                             env?
-                                                                                             make-env
-                                                                                             set-import-interface-new-marks!
-                                                                                             set-import-interface-interface!
-                                                                                             import-interface-new-marks
-                                                                                             import-interface-interface
-                                                                                             import-interface?
-                                                                                             make-import-interface
-                                                                                             set-top-ribcage-mutable?!
-                                                                                             set-top-ribcage-key!
-                                                                                             top-ribcage-mutable?
-                                                                                             top-ribcage-key
-                                                                                             top-ribcage?
-                                                                                             make-top-ribcage
-                                                                                             set-ribcage-labels!
-                                                                                             set-ribcage-marks!
-                                                                                             set-ribcage-symnames!
-                                                                                             ribcage-labels
-                                                                                             ribcage-marks
-                                                                                             ribcage-symnames
-                                                                                             ribcage?
-                                                                                             make-ribcage
-                                                                                             gen-labels
-                                                                                             label?
-                                                                                             gen-label
-                                                                                             set-indirect-label!
-                                                                                             get-indirect-label
-                                                                                             indirect-label?
-                                                                                             gen-indirect-label
-                                                                                             anon
-                                                                                             only-top-marked?
-                                                                                             top-marked?
-                                                                                             top-wrap
-                                                                                             empty-wrap
-                                                                                             wrap-subst
-                                                                                             wrap-marks
-                                                                                             make-wrap
-                                                                                             id-sym-name&marks
-                                                                                             id-subst
-                                                                                             id-marks
-                                                                                             id-sym-name
-                                                                                             id?
-                                                                                             nonsymbol-id?
-                                                                                             global-extend
-                                                                                             defer-or-eval-transformer
-                                                                                             make-transformer-binding
-                                                                                             lookup
-                                                                                             lookup*
-                                                                                             displaced-lexical-error
-                                                                                             displaced-lexical?
-                                                                                             extend-var-env*
-                                                                                             extend-env*
-                                                                                             extend-env
-                                                                                             null-env
-                                                                                             binding?
-                                                                                             set-binding-value!
-                                                                                             set-binding-type!
-                                                                                             binding-value
-                                                                                             binding-type
-                                                                                             make-binding
-                                                                                             sanitize-binding
-                                                                                             arg-check
-                                                                                             no-source
-                                                                                             unannotate
-                                                                                             self-evaluating?
-                                                                                             lexical-var?
-                                                                                             build-lexical-var
-                                                                                             build-top-module
-                                                                                             build-body
-                                                                                             build-letrec
-                                                                                             build-sequence
-                                                                                             build-data
-                                                                                             build-primref
-                                                                                             built-lambda?
-                                                                                             build-lambda
-                                                                                             build-revisit-only
-                                                                                             build-visit-only
-                                                                                             build-cte-install
-                                                                                             build-global-definition
-                                                                                             build-global-assignment
-                                                                                             build-global-reference
-                                                                                             build-lexical-assignment
-                                                                                             build-lexical-reference
-                                                                                             build-conditional
-                                                                                             build-application
-                                                                                             generate-id
-                                                                                             put-import-binding
-                                                                                             get-import-binding
-                                                                                             read-only-binding?
-                                                                                             put-global-definition-hook
-                                                                                             get-global-definition-hook
-                                                                                             put-cte-hook
-                                                                                             gensym-hook
-                                                                                             error-hook
-                                                                                             define-top-level-value-hook
-                                                                                             local-eval-hook
-                                                                                             top-level-eval-hook
-                                                                                             annotation?
-                                                                                             set-syntax-object-wrap!
-                                                                                             set-syntax-object-expression!
-                                                                                             syntax-object-wrap
-                                                                                             syntax-object-expression
-                                                                                             syntax-object?
-                                                                                             make-syntax-object
-                                                                                             noexpand
-                                                                                             let-values
-                                                                                             define-structure
-                                                                                             unless
-                                                                                             when)
-                                                                                            ((top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             ("m" top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             ("m" top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top)
-                                                                                             (top))
-                                                                                            ("i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"
-                                                                                             "i"))
-                                                                                          #(top-ribcage
-                                                                                            *top*
-                                                                                            #t))))
-                                                                                     any
-                                                                                     any))))])
-                                                                        (#%$syntax-dispatch
-                                                                          g849
-                                                                          '(#(free-id
-                                                                              #(syntax-object
-                                                                                except
-                                                                                ((top)
-                                                                                  #(ribcage
-                                                                                    #(orig
-                                                                                      import-only?)
-                                                                                    #((top)
-                                                                                      (top))
-                                                                                    #("i"
-                                                                                      "i"))
-                                                                                  #(ribcage
-                                                                                    ()
-                                                                                    ()
-                                                                                    ())
-                                                                                  #(ribcage
-                                                                                    #(m
-                                                                                      exports?)
-                                                                                    #((top)
-                                                                                      (top))
-                                                                                    #("i"
-                                                                                      "i"))
-                                                                                  #(ribcage
-                                                                                    (modspec*
-                                                                                      modspec
-                                                                                      gen-mid
-                                                                                      prefix-drop
-                                                                                      prefix-add
-                                                                                      difference)
-                                                                                    ((top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top))
-                                                                                    ("i" "i"
-                                                                                         "i"
-                                                                                         "i"
-                                                                                         "i"
-                                                                                         "i"))
-                                                                                  #(ribcage
-                                                                                    #(r)
-                                                                                    #((top))
-                                                                                    #("i"))
-                                                                                  #(ribcage
-                                                                                    ()
-                                                                                    ()
-                                                                                    ())
-                                                                                  #(ribcage
-                                                                                    #(orig
-                                                                                      import-only?)
-                                                                                    #((top)
-                                                                                      (top))
-                                                                                    #("i"
-                                                                                      "i"))
-                                                                                  #(ribcage
-                                                                                    ($import-help
-                                                                                      $module-exports)
-                                                                                    ((top)
-                                                                                      (top))
-                                                                                    ("i" "i"))
-                                                                                  #(ribcage
-                                                                                    (lambda-var-list
-                                                                                     gen-var
-                                                                                     strip
-                                                                                     strip*
-                                                                                     strip-annotation
-                                                                                     ellipsis?
-                                                                                     chi-void
-                                                                                     chi-local-syntax
-                                                                                     chi-lambda-clause
-                                                                                     parse-begin
-                                                                                     parse-alias
-                                                                                     parse-eval-when
-                                                                                     parse-meta
-                                                                                     parse-define-syntax
-                                                                                     parse-define
-                                                                                     parse-import
-                                                                                     parse-module
-                                                                                     do-import!
-                                                                                     lookup-import-label
-                                                                                     import-mark-delta
-                                                                                     chi-internal
-                                                                                     chi-body
-                                                                                     chi-macro
-                                                                                     chi-set!
-                                                                                     chi-application
-                                                                                     chi-expr
-                                                                                     chi
-                                                                                     chi-sequence
-                                                                                     chi-meta-frob
-                                                                                     chi-frobs
-                                                                                     ct-eval/residualize3
-                                                                                     ct-eval/residualize2
-                                                                                     rt-eval/residualize
-                                                                                     initial-mode-set
-                                                                                     update-mode-set
-                                                                                     do-top-import
-                                                                                     vfor-each
-                                                                                     vmap
-                                                                                     chi-external
-                                                                                     check-defined-ids
-                                                                                     check-module-exports
-                                                                                     id-set-diff
-                                                                                     chi-top-module
-                                                                                     set-frob-meta?!
-                                                                                     set-frob-e!
-                                                                                     frob-meta?
-                                                                                     frob-e
-                                                                                     frob?
-                                                                                     make-frob
-                                                                                     create-module-binding
-                                                                                     set-module-binding-exported!
-                                                                                     set-module-binding-val!
-                                                                                     set-module-binding-imps!
-                                                                                     set-module-binding-label!
-                                                                                     set-module-binding-id!
-                                                                                     set-module-binding-type!
-                                                                                     module-binding-exported
-                                                                                     module-binding-val
-                                                                                     module-binding-imps
-                                                                                     module-binding-label
-                                                                                     module-binding-id
-                                                                                     module-binding-type
-                                                                                     module-binding?
-                                                                                     make-module-binding
-                                                                                     make-resolved-interface
-                                                                                     make-unresolved-interface
-                                                                                     set-interface-token!
-                                                                                     set-interface-exports!
-                                                                                     set-interface-marks!
-                                                                                     interface-token
-                                                                                     interface-exports
-                                                                                     interface-marks
-                                                                                     interface?
-                                                                                     make-interface
-                                                                                     flatten-exports
-                                                                                     chi-top
-                                                                                     chi-top-sequence
-                                                                                     chi-top*
-                                                                                     syntax-type
-                                                                                     chi-when-list
-                                                                                     source-wrap
-                                                                                     wrap
-                                                                                     bound-id-member?
-                                                                                     invalid-ids-error
-                                                                                     distinct-bound-ids?
-                                                                                     valid-bound-ids?
-                                                                                     bound-id=?
-                                                                                     help-bound-id=?
-                                                                                     literal-id=?
-                                                                                     free-id=?
-                                                                                     id-var-name
-                                                                                     id-var-name-loc
-                                                                                     id-var-name&marks
-                                                                                     id-var-name-loc&marks
-                                                                                     top-id-free-var-name
-                                                                                     top-id-bound-var-name
-                                                                                     anon
-                                                                                     diff-marks
-                                                                                     same-marks?
-                                                                                     join-subst
-                                                                                     join-marks
-                                                                                     join-wraps
-                                                                                     smart-append
-                                                                                     resolved-id-var-name
-                                                                                     id->resolved-id
-                                                                                     make-resolved-id
-                                                                                     make-binding-wrap
-                                                                                     store-import-binding
-                                                                                     lookup-import-binding-name
-                                                                                     extend-ribcage-subst!
-                                                                                     extend-ribcage-barrier-help!
-                                                                                     extend-ribcage-barrier!
-                                                                                     import-extend-ribcage!
-                                                                                     extend-ribcage!
-                                                                                     make-empty-ribcage
-                                                                                     barrier-marker
-                                                                                     new-mark
-                                                                                     anti-mark
-                                                                                     the-anti-mark
-                                                                                     set-env-wrap!
-                                                                                     set-env-top-ribcage!
-                                                                                     env-wrap
-                                                                                     env-top-ribcage
-                                                                                     env?
-                                                                                     make-env
-                                                                                     set-import-interface-new-marks!
-                                                                                     set-import-interface-interface!
-                                                                                     import-interface-new-marks
-                                                                                     import-interface-interface
-                                                                                     import-interface?
-                                                                                     make-import-interface
-                                                                                     set-top-ribcage-mutable?!
-                                                                                     set-top-ribcage-key!
-                                                                                     top-ribcage-mutable?
-                                                                                     top-ribcage-key
-                                                                                     top-ribcage?
-                                                                                     make-top-ribcage
-                                                                                     set-ribcage-labels!
-                                                                                     set-ribcage-marks!
-                                                                                     set-ribcage-symnames!
-                                                                                     ribcage-labels
-                                                                                     ribcage-marks
-                                                                                     ribcage-symnames
-                                                                                     ribcage?
-                                                                                     make-ribcage
-                                                                                     gen-labels
-                                                                                     label?
-                                                                                     gen-label
-                                                                                     set-indirect-label!
-                                                                                     get-indirect-label
-                                                                                     indirect-label?
-                                                                                     gen-indirect-label
-                                                                                     anon
-                                                                                     only-top-marked?
-                                                                                     top-marked?
-                                                                                     top-wrap
-                                                                                     empty-wrap
-                                                                                     wrap-subst
-                                                                                     wrap-marks
-                                                                                     make-wrap
-                                                                                     id-sym-name&marks
-                                                                                     id-subst
-                                                                                     id-marks
-                                                                                     id-sym-name
-                                                                                     id?
-                                                                                     nonsymbol-id?
-                                                                                     global-extend
-                                                                                     defer-or-eval-transformer
-                                                                                     make-transformer-binding
-                                                                                     lookup
-                                                                                     lookup*
-                                                                                     displaced-lexical-error
-                                                                                     displaced-lexical?
-                                                                                     extend-var-env*
-                                                                                     extend-env*
-                                                                                     extend-env
-                                                                                     null-env
-                                                                                     binding?
-                                                                                     set-binding-value!
-                                                                                     set-binding-type!
-                                                                                     binding-value
-                                                                                     binding-type
-                                                                                     make-binding
-                                                                                     sanitize-binding
-                                                                                     arg-check
-                                                                                     no-source
-                                                                                     unannotate
-                                                                                     self-evaluating?
-                                                                                     lexical-var?
-                                                                                     build-lexical-var
-                                                                                     build-top-module
-                                                                                     build-body
-                                                                                     build-letrec
-                                                                                     build-sequence
-                                                                                     build-data
-                                                                                     build-primref
-                                                                                     built-lambda?
-                                                                                     build-lambda
-                                                                                     build-revisit-only
-                                                                                     build-visit-only
-                                                                                     build-cte-install
-                                                                                     build-global-definition
-                                                                                     build-global-assignment
-                                                                                     build-global-reference
-                                                                                     build-lexical-assignment
-                                                                                     build-lexical-reference
-                                                                                     build-conditional
-                                                                                     build-application
-                                                                                     generate-id
-                                                                                     put-import-binding
-                                                                                     get-import-binding
-                                                                                     read-only-binding?
-                                                                                     put-global-definition-hook
-                                                                                     get-global-definition-hook
-                                                                                     put-cte-hook
-                                                                                     gensym-hook
-                                                                                     error-hook
-                                                                                     define-top-level-value-hook
-                                                                                     local-eval-hook
-                                                                                     top-level-eval-hook
-                                                                                     annotation?
-                                                                                     set-syntax-object-wrap!
-                                                                                     set-syntax-object-expression!
-                                                                                     syntax-object-wrap
-                                                                                     syntax-object-expression
-                                                                                     syntax-object?
-                                                                                     make-syntax-object
-                                                                                     noexpand
-                                                                                     let-values
-                                                                                     define-structure
-                                                                                     unless
-                                                                                     when)
-                                                                                    ((top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     ("m" top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     ("m" top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top))
-                                                                                    ("i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"))
-                                                                                  #(top-ribcage
-                                                                                    *top*
-                                                                                    #t))))
-                                                                             any
-                                                                             .
-                                                                             each-any))))])
-                                                                (#%$syntax-dispatch
-                                                                  g849
-                                                                  '(#(free-id
-                                                                      #(syntax-object
-                                                                        only
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(orig
-                                                                              import-only?)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(m
-                                                                              exports?)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            (modspec*
-                                                                              modspec
-                                                                              gen-mid
-                                                                              prefix-drop
-                                                                              prefix-add
-                                                                              difference)
-                                                                            ((top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top))
-                                                                            ("i" "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"
-                                                                                 "i"))
-                                                                          #(ribcage
-                                                                            #(r)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(orig
-                                                                              import-only?)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ($import-help
-                                                                              $module-exports)
-                                                                            ((top)
-                                                                              (top))
-                                                                            ("i" "i"))
-                                                                          #(ribcage
-                                                                            (lambda-var-list
-                                                                             gen-var
-                                                                             strip
-                                                                             strip*
-                                                                             strip-annotation
-                                                                             ellipsis?
-                                                                             chi-void
-                                                                             chi-local-syntax
-                                                                             chi-lambda-clause
-                                                                             parse-begin
-                                                                             parse-alias
-                                                                             parse-eval-when
-                                                                             parse-meta
-                                                                             parse-define-syntax
-                                                                             parse-define
-                                                                             parse-import
-                                                                             parse-module
-                                                                             do-import!
-                                                                             lookup-import-label
-                                                                             import-mark-delta
-                                                                             chi-internal
-                                                                             chi-body
-                                                                             chi-macro
-                                                                             chi-set!
-                                                                             chi-application
-                                                                             chi-expr
-                                                                             chi
-                                                                             chi-sequence
-                                                                             chi-meta-frob
-                                                                             chi-frobs
-                                                                             ct-eval/residualize3
-                                                                             ct-eval/residualize2
-                                                                             rt-eval/residualize
-                                                                             initial-mode-set
-                                                                             update-mode-set
-                                                                             do-top-import
-                                                                             vfor-each
-                                                                             vmap
-                                                                             chi-external
-                                                                             check-defined-ids
-                                                                             check-module-exports
-                                                                             id-set-diff
-                                                                             chi-top-module
-                                                                             set-frob-meta?!
-                                                                             set-frob-e!
-                                                                             frob-meta?
-                                                                             frob-e
-                                                                             frob?
-                                                                             make-frob
-                                                                             create-module-binding
-                                                                             set-module-binding-exported!
-                                                                             set-module-binding-val!
-                                                                             set-module-binding-imps!
-                                                                             set-module-binding-label!
-                                                                             set-module-binding-id!
-                                                                             set-module-binding-type!
-                                                                             module-binding-exported
-                                                                             module-binding-val
-                                                                             module-binding-imps
-                                                                             module-binding-label
-                                                                             module-binding-id
-                                                                             module-binding-type
-                                                                             module-binding?
-                                                                             make-module-binding
-                                                                             make-resolved-interface
-                                                                             make-unresolved-interface
-                                                                             set-interface-token!
-                                                                             set-interface-exports!
-                                                                             set-interface-marks!
-                                                                             interface-token
-                                                                             interface-exports
-                                                                             interface-marks
-                                                                             interface?
-                                                                             make-interface
-                                                                             flatten-exports
-                                                                             chi-top
-                                                                             chi-top-sequence
-                                                                             chi-top*
-                                                                             syntax-type
-                                                                             chi-when-list
-                                                                             source-wrap
-                                                                             wrap
-                                                                             bound-id-member?
-                                                                             invalid-ids-error
-                                                                             distinct-bound-ids?
-                                                                             valid-bound-ids?
-                                                                             bound-id=?
-                                                                             help-bound-id=?
-                                                                             literal-id=?
-                                                                             free-id=?
-                                                                             id-var-name
-                                                                             id-var-name-loc
-                                                                             id-var-name&marks
-                                                                             id-var-name-loc&marks
-                                                                             top-id-free-var-name
-                                                                             top-id-bound-var-name
-                                                                             anon
-                                                                             diff-marks
-                                                                             same-marks?
-                                                                             join-subst
-                                                                             join-marks
-                                                                             join-wraps
-                                                                             smart-append
-                                                                             resolved-id-var-name
-                                                                             id->resolved-id
-                                                                             make-resolved-id
-                                                                             make-binding-wrap
-                                                                             store-import-binding
-                                                                             lookup-import-binding-name
-                                                                             extend-ribcage-subst!
-                                                                             extend-ribcage-barrier-help!
-                                                                             extend-ribcage-barrier!
-                                                                             import-extend-ribcage!
-                                                                             extend-ribcage!
-                                                                             make-empty-ribcage
-                                                                             barrier-marker
-                                                                             new-mark
-                                                                             anti-mark
-                                                                             the-anti-mark
-                                                                             set-env-wrap!
-                                                                             set-env-top-ribcage!
-                                                                             env-wrap
-                                                                             env-top-ribcage
-                                                                             env?
-                                                                             make-env
-                                                                             set-import-interface-new-marks!
-                                                                             set-import-interface-interface!
-                                                                             import-interface-new-marks
-                                                                             import-interface-interface
-                                                                             import-interface?
-                                                                             make-import-interface
-                                                                             set-top-ribcage-mutable?!
-                                                                             set-top-ribcage-key!
-                                                                             top-ribcage-mutable?
-                                                                             top-ribcage-key
-                                                                             top-ribcage?
-                                                                             make-top-ribcage
-                                                                             set-ribcage-labels!
-                                                                             set-ribcage-marks!
-                                                                             set-ribcage-symnames!
-                                                                             ribcage-labels
-                                                                             ribcage-marks
-                                                                             ribcage-symnames
-                                                                             ribcage?
-                                                                             make-ribcage
-                                                                             gen-labels
-                                                                             label?
-                                                                             gen-label
-                                                                             set-indirect-label!
-                                                                             get-indirect-label
-                                                                             indirect-label?
-                                                                             gen-indirect-label
-                                                                             anon
-                                                                             only-top-marked?
-                                                                             top-marked?
-                                                                             top-wrap
-                                                                             empty-wrap
-                                                                             wrap-subst
-                                                                             wrap-marks
-                                                                             make-wrap
-                                                                             id-sym-name&marks
-                                                                             id-subst
-                                                                             id-marks
-                                                                             id-sym-name
-                                                                             id?
-                                                                             nonsymbol-id?
-                                                                             global-extend
-                                                                             defer-or-eval-transformer
-                                                                             make-transformer-binding
-                                                                             lookup
-                                                                             lookup*
-                                                                             displaced-lexical-error
-                                                                             displaced-lexical?
-                                                                             extend-var-env*
-                                                                             extend-env*
-                                                                             extend-env
-                                                                             null-env
-                                                                             binding?
-                                                                             set-binding-value!
-                                                                             set-binding-type!
-                                                                             binding-value
-                                                                             binding-type
-                                                                             make-binding
-                                                                             sanitize-binding
-                                                                             arg-check
-                                                                             no-source
-                                                                             unannotate
-                                                                             self-evaluating?
-                                                                             lexical-var?
-                                                                             build-lexical-var
-                                                                             build-top-module
-                                                                             build-body
-                                                                             build-letrec
-                                                                             build-sequence
-                                                                             build-data
-                                                                             build-primref
-                                                                             built-lambda?
-                                                                             build-lambda
-                                                                             build-revisit-only
-                                                                             build-visit-only
-                                                                             build-cte-install
-                                                                             build-global-definition
-                                                                             build-global-assignment
-                                                                             build-global-reference
-                                                                             build-lexical-assignment
-                                                                             build-lexical-reference
-                                                                             build-conditional
-                                                                             build-application
-                                                                             generate-id
-                                                                             put-import-binding
-                                                                             get-import-binding
-                                                                             read-only-binding?
-                                                                             put-global-definition-hook
-                                                                             get-global-definition-hook
-                                                                             put-cte-hook
-                                                                             gensym-hook
-                                                                             error-hook
-                                                                             define-top-level-value-hook
-                                                                             local-eval-hook
-                                                                             top-level-eval-hook
-                                                                             annotation?
-                                                                             set-syntax-object-wrap!
-                                                                             set-syntax-object-expression!
-                                                                             syntax-object-wrap
-                                                                             syntax-object-expression
-                                                                             syntax-object?
-                                                                             make-syntax-object
-                                                                             noexpand
-                                                                             let-values
-                                                                             define-structure
-                                                                             unless
-                                                                             when)
-                                                                            ((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             ("m" top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             ("m" top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                            ("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t))))
-                                                                     any
-                                                                     .
-                                                                     each-any)))])
-                                                            g843)])
-                                                       g846)
-                                                     (#%syntax-error
-                                                       g845))])
-                                               (#%$syntax-dispatch
-                                                 g845
-                                                 '(any any)))])
-                                           ((top-level-value 'list)
-                                             g809
-                                             g810))])
-                                      (case-lambda
-                                        [(g957)
-                                         ((top-level-value
-                                            'call-with-values)
-                                           (case-lambda
-                                             [() (g816 g957 '#f)])
-                                           (case-lambda
-                                             [(g958 g959 g960) g959]))]))])
-                                  (void) (void) (void) (void) (void)
-                                  (void))])]))])
-                      (void)
-                      (void))]))
-                ((top-level-value 'primitive-set!)
-                  'expand-mode
-                  ((top-level-value 'make-parameter)
-                    'eval
-                    (case-lambda
-                      [(g961)
-                       (begin
-                         (if ((top-level-value 'not)
-                               ((top-level-value 'memq)
-                                 g961
-                                 '(eval compile bootstrap)))
-                             ((top-level-value 'error)
-                               'expand-mode
-                               '"~s is not a valid mode"
-                               g961)
-                             (#%void))
-                         g961)])))
-                ((top-level-value 'primitive-set!)
-                  'sc-expand
-                  ((case-lambda
-                     [()
-                      ((case-lambda
-                         [(g962)
-                          ((case-lambda
-                             [(g963)
-                              (begin
-                                (set! g962 g963)
-                                (case-lambda
-                                  [(g964)
-                                   ((case-lambda
-                                      [(g965)
-                                       ((top-level-value 'call-with-values)
-                                         (case-lambda [() (g962)])
-                                         (case-lambda
-                                           [(g966 g967)
-                                            (if (if ((top-level-value
-                                                       'pair?)
-                                                      g964)
-                                                    ((top-level-value
-                                                       'equal?)
-                                                      ((top-level-value
-                                                         'car)
-                                                        g964)
-                                                      g0)
-                                                    '#f)
-                                                ((top-level-value 'cadr)
-                                                  g964)
-                                                (g123 g964 '() (g81 g965)
-                                                  g966 g967 '#f
-                                                  (g80 g965)))]))])
-                                     ((top-level-value
-                                        'interaction-environment)))]))])
-                            (case-lambda
-                              [()
-                               ((case-lambda
-                                  [(g968)
-                                   (if ((top-level-value 'memv)
-                                         g968
-                                         '(eval))
-                                       ((top-level-value 'values)
-                                         '(e)
-                                         '(e))
-                                       (if ((top-level-value 'memv)
-                                             g968
-                                             '(compile))
-                                           ((top-level-value 'values)
-                                             '(l c)
-                                             '(l))
-                                           (if ((top-level-value 'memv)
-                                                 g968
-                                                 '(bootstrap))
-                                               ((top-level-value 'values)
-                                                 '(l)
-                                                 '(l))
-                                               (#%void))))])
-                                 ((top-level-value 'expand-mode)))]))])
-                        (void))])))
-                ((top-level-value 'primitive-set!)
-                  '$make-environment
-                  (case-lambda
-                    [(g969 g970)
-                     ((case-lambda
-                        [(g971)
-                         (g78 g971
-                              (g45 (g46 '((top)))
-                                   ((top-level-value 'cons)
-                                     g971
-                                     (g47 '((top))))))])
-                       (g66 g969 g970))]))
-                ((top-level-value 'primitive-set!)
-                  'environment?
-                  (case-lambda [(g972) (g79 g972)]))
-                ((top-level-value 'primitive-set!)
-                  'interaction-environment
-                  ((case-lambda [(g973) (case-lambda [() g973])])
-                    ((top-level-value '$make-environment) '*top* '#t)))
-                ((top-level-value 'primitive-set!)
-                  'identifier?
-                  (case-lambda [(g974) (g40 g974)]))
-                ((top-level-value 'primitive-set!)
-                  'datum->syntax-object
-                  (case-lambda
-                    [(g975 g976)
-                     (begin
-                       ((case-lambda
-                          [(g977)
-                           (if ((top-level-value 'not) (g40 g977))
-                               (g11 'datum->syntax-object
-                                    '"invalid argument"
-                                    g977)
-                               (#%void))])
-                         g975)
-                       (g1 g976 (g4 g975)))]))
-                ((top-level-value 'primitive-set!)
-                  'syntax->list
-                  (case-lambda
-                    [(g978)
-                     (((case-lambda
-                         [(g979)
-                          ((case-lambda
-                             [(g980) (begin (set! g979 g980) g979)])
-                            (case-lambda
-                              [(g981)
-                               ((case-lambda
-                                  [(g982)
-                                   ((case-lambda
-                                      [(g983)
-                                       (if g983
-                                           (#%apply
-                                             (case-lambda [() '()])
-                                             g983)
-                                           ((case-lambda
-                                              [(g984)
-                                               (if g984
-                                                   (#%apply
-                                                     (case-lambda
-                                                       [(g985 g986)
-                                                        ((top-level-value
-                                                           'cons)
-                                                          g985
-                                                          (g979 g986))])
-                                                     g984)
-                                                   ((case-lambda
-                                                      [(g987)
-                                                       ((top-level-value
-                                                          'error)
-                                                         'syntax->list
-                                                         '"invalid argument ~s"
-                                                         g978)])
-                                                     g982))])
-                                             (#%$syntax-dispatch
-                                               g982
-                                               '(any . any))))])
-                                     (#%$syntax-dispatch g982 '()))])
-                                 g981)]))])
-                        (void))
-                       g978)]))
-                ((top-level-value 'primitive-set!)
-                  'syntax->vector
-                  (case-lambda
-                    [(g988)
-                     ((case-lambda
-                        [(g989)
-                         ((case-lambda
-                            [(g990)
-                             (if g990
-                                 (#%apply
-                                   (case-lambda
-                                     [(g991)
-                                      ((top-level-value 'apply)
-                                        (top-level-value 'vector)
-                                        ((top-level-value 'syntax->list)
-                                          g991))])
-                                   g990)
-                                 ((case-lambda
-                                    [(g992)
-                                     ((top-level-value 'error)
-                                       'syntax->vector
-                                       '"invalid argument ~s"
-                                       g988)])
-                                   g989))])
-                           (#%$syntax-dispatch g989 '#(vector each-any)))])
-                       g988)]))
-                ((top-level-value 'primitive-set!)
-                  'syntax-object->datum
-                  (case-lambda [(g993) (g198 g993 '(()))]))
-                ((top-level-value 'primitive-set!)
-                  'generate-temporaries
-                  (case-lambda
-                    [(g994)
-                     (begin
-                       ((case-lambda
-                          [(g995)
-                           (if ((top-level-value 'not)
-                                 ((top-level-value 'list?) g995))
-                               (g11 'generate-temporaries
-                                    '"invalid argument"
-                                    g995)
-                               (#%void))])
-                         g994)
-                       ((top-level-value 'map)
-                         (case-lambda
-                           [(g996)
-                            (g119 ((top-level-value 'gensym)) '((top)))])
-                         g994))]))
-                ((top-level-value 'primitive-set!)
-                  'free-identifier=?
-                  (case-lambda
-                    [(g997 g998)
-                     (begin
-                       ((case-lambda
-                          [(g999)
-                           (if ((top-level-value 'not) (g40 g999))
-                               (g11 'free-identifier=?
-                                    '"invalid argument"
-                                    g999)
-                               (#%void))])
-                         g997)
-                       ((case-lambda
-                          [(g1000)
-                           (if ((top-level-value 'not) (g40 g1000))
-                               (g11 'free-identifier=?
-                                    '"invalid argument"
-                                    g1000)
-                               (#%void))])
-                         g998)
-                       (g111 g997 g998))]))
-                ((top-level-value 'primitive-set!)
-                  'bound-identifier=?
-                  (case-lambda
-                    [(g1001 g1002)
-                     (begin
-                       ((case-lambda
-                          [(g1003)
-                           (if ((top-level-value 'not) (g40 g1003))
-                               (g11 'bound-identifier=?
-                                    '"invalid argument"
-                                    g1003)
-                               (#%void))])
-                         g1001)
-                       ((case-lambda
-                          [(g1004)
-                           (if ((top-level-value 'not) (g40 g1004))
-                               (g11 'bound-identifier=?
-                                    '"invalid argument"
-                                    g1004)
-                               (#%void))])
-                         g1002)
-                       (g114 g1001 g1002))]))
-                ((top-level-value 'primitive-set!)
-                  'literal-identifier=?
-                  (case-lambda
-                    [(g1005 g1006)
-                     (begin
-                       ((case-lambda
-                          [(g1007)
-                           (if ((top-level-value 'not) (g40 g1007))
-                               (g11 'literal-identifier=?
-                                    '"invalid argument"
-                                    g1007)
-                               (#%void))])
-                         g1005)
-                       ((case-lambda
-                          [(g1008)
-                           (if ((top-level-value 'not) (g40 g1008))
-                               (g11 'literal-identifier=?
-                                    '"invalid argument"
-                                    g1008)
-                               (#%void))])
-                         g1006)
-                       (g112 g1005 g1006))]))
-                ((top-level-value 'primitive-set!)
-                  'syntax-error
-                  (case-lambda
-                    [(g1009 . g1010)
-                     (begin
-                       ((top-level-value 'for-each)
-                         (case-lambda
-                           [(g1011)
-                            ((case-lambda
-                               [(g1012)
-                                (if ((top-level-value 'not)
-                                      ((top-level-value 'string?) g1012))
-                                    (g11 'syntax-error
-                                         '"invalid argument"
-                                         g1012)
-                                    (#%void))])
-                              g1011)])
-                         g1010)
-                       ((case-lambda
-                          [(g1013) (g11 '#f g1013 (g198 g1009 '(())))])
-                         (if ((top-level-value 'null?) g1010)
-                             '"invalid syntax"
-                             ((top-level-value 'apply)
-                               (top-level-value 'string-append)
-                               g1010))))]))
-                ((case-lambda
-                   [()
-                    ((case-lambda
-                       [(g1014 g1015 g1016 g1017 g1018 g1019 g1020)
-                        ((case-lambda
-                           [(g1021 g1022 g1023 g1024 g1025 g1026 g1027)
-                            (begin
-                              (set! g1014 g1021)
-                              (set! g1015 g1022)
-                              (set! g1016 g1023)
-                              (set! g1017 g1024)
-                              (set! g1018 g1025)
-                              (set! g1019 g1026)
-                              (set! g1020 g1027)
-                              (set-top-level-value!
-                                '$syntax-dispatch
-                                (case-lambda
-                                  [(g1028 g1029)
-                                   (if ((top-level-value 'eq?) g1029 'any)
-                                       ((top-level-value 'list) g1028)
-                                       (if (g2 g1028)
-                                           (g1019
-                                             ((case-lambda
-                                                [(g1030)
-                                                 (if (g7 g1030)
-                                                     ((top-level-value
-                                                        'annotation-expression)
-                                                       g1030)
-                                                     g1030)])
-                                               (g3 g1028))
-                                             g1029
-                                             (g4 g1028)
-                                             '())
-                                           (g1019
-                                             ((case-lambda
-                                                [(g1031)
-                                                 (if (g7 g1031)
-                                                     ((top-level-value
-                                                        'annotation-expression)
-                                                       g1031)
-                                                     g1031)])
-                                               g1028)
-                                             g1029
-                                             '(())
-                                             '())))])))])
-                          (case-lambda
-                            [(g1032 g1033 g1034)
-                             (if (g7 g1032)
-                                 (g1014
-                                   ((top-level-value
-                                      'annotation-expression)
-                                     g1032)
-                                   g1033
-                                   g1034)
-                                 (if ((top-level-value 'pair?) g1032)
-                                     ((case-lambda
-                                        [(g1035)
-                                         (if g1035
-                                             ((case-lambda
-                                                [(g1036)
-                                                 (if g1036
-                                                     ((top-level-value
-                                                        'cons)
-                                                       g1035
-                                                       g1036)
-                                                     '#f)])
-                                               (g1014
-                                                 ((top-level-value 'cdr)
-                                                   g1032)
-                                                 g1033
-                                                 g1034))
-                                             '#f)])
-                                       (g1020
-                                         ((top-level-value 'car) g1032)
-                                         g1033
-                                         g1034
-                                         '()))
-                                     (if ((top-level-value 'null?) g1032)
-                                         '()
-                                         (if (g2 g1032)
-                                             (g1014
-                                               (g3 g1032)
-                                               g1033
-                                               (g98 g1034 (g4 g1032)))
-                                             '#f))))])
-                          (case-lambda
-                            [(g1037 g1038 g1039 g1040 g1041 g1042)
-                             (((case-lambda
-                                 [(g1043)
-                                  ((case-lambda
-                                     [(g1044)
-                                      (begin (set! g1043 g1044) g1043)])
-                                    (case-lambda
-                                      [(g1045 g1046)
-                                       (if ((top-level-value 'pair?) g1045)
-                                           ((top-level-value
-                                              'call-with-values)
-                                             (case-lambda
-                                               [()
-                                                (g1043
-                                                  ((top-level-value 'cdr)
-                                                    g1045)
-                                                  g1046)])
-                                             (case-lambda
-                                               [(g1047 g1048 g1049)
-                                                (if g1049
-                                                    (if ((top-level-value
-                                                           'null?)
-                                                          g1048)
-                                                        ((case-lambda
-                                                           [(g1050)
-                                                            (if g1050
-                                                                ((top-level-value
-                                                                   'values)
-                                                                  ((top-level-value
-                                                                     'cons)
-                                                                    g1050
-                                                                    g1047)
-                                                                  g1048
-                                                                  g1049)
-                                                                ((top-level-value
-                                                                   'values)
-                                                                  '#f
-                                                                  '#f
-                                                                  '#f))])
-                                                          (g1020
-                                                            ((top-level-value
-                                                               'car)
-                                                              g1045)
-                                                            g1038
-                                                            g1046
-                                                            '()))
-                                                        ((top-level-value
-                                                           'values)
-                                                          '()
-                                                          ((top-level-value
-                                                             'cdr)
-                                                            g1048)
-                                                          (g1020
-                                                            ((top-level-value
-                                                               'car)
-                                                              g1045)
-                                                            ((top-level-value
-                                                               'car)
-                                                              g1048)
-                                                            g1046
-                                                            g1049)))
-                                                    ((top-level-value
-                                                       'values)
-                                                      '#f
-                                                      '#f
-                                                      '#f))]))
-                                           (if (g7 g1045)
-                                               (g1043
-                                                 ((top-level-value
-                                                    'annotation-expression)
-                                                   g1045)
-                                                 g1046)
-                                               (if (g2 g1045)
-                                                   (g1043
-                                                     (g3 g1045)
-                                                     (g98 g1046
-                                                          (g4 g1045)))
-                                                   ((top-level-value
-                                                      'values)
-                                                     '()
-                                                     g1039
-                                                     (g1020
-                                                       g1045
-                                                       g1040
-                                                       g1046
-                                                       g1042)))))]))])
-                                (void))
-                               g1037
-                               g1041)])
-                          (case-lambda
-                            [(g1051 g1052)
-                             (if (g7 g1051)
-                                 (g1016
-                                   ((top-level-value
-                                      'annotation-expression)
-                                     g1051)
-                                   g1052)
-                                 (if ((top-level-value 'pair?) g1051)
-                                     ((case-lambda
-                                        [(g1053)
-                                         (if g1053
-                                             ((top-level-value 'cons)
-                                               (g119
-                                                 ((top-level-value 'car)
-                                                   g1051)
-                                                 g1052)
-                                               g1053)
-                                             '#f)])
-                                       (g1016
-                                         ((top-level-value 'cdr) g1051)
-                                         g1052))
-                                     (if ((top-level-value 'null?) g1051)
-                                         '()
-                                         (if (g2 g1051)
-                                             (g1016
-                                               (g3 g1051)
-                                               (g98 g1052 (g4 g1051)))
-                                             '#f))))])
-                          (case-lambda
-                            [(g1054 g1055)
-                             (if ((top-level-value 'null?) g1054)
-                                 g1055
-                                 (if ((top-level-value 'eq?) g1054 'any)
-                                     ((top-level-value 'cons) '() g1055)
-                                     (if ((top-level-value 'pair?) g1054)
-                                         (g1017
-                                           ((top-level-value 'car) g1054)
-                                           (g1017
-                                             ((top-level-value 'cdr) g1054)
-                                             g1055))
-                                         (if ((top-level-value 'eq?)
-                                               g1054
-                                               'each-any)
-                                             ((top-level-value 'cons)
-                                               '()
-                                               g1055)
-                                             ((case-lambda
-                                                [(g1056)
-                                                 (if ((top-level-value
-                                                        'memv)
-                                                       g1056
-                                                       '(each))
-                                                     (g1017
-                                                       ((top-level-value
-                                                          'vector-ref)
-                                                         g1054
-                                                         '1)
-                                                       g1055)
-                                                     (if ((top-level-value
-                                                            'memv)
-                                                           g1056
-                                                           '(each+))
-                                                         (g1017
-                                                           ((top-level-value
-                                                              'vector-ref)
-                                                             g1054
-                                                             '1)
-                                                           (g1017
-                                                             ((top-level-value
-                                                                'reverse)
-                                                               ((top-level-value
-                                                                  'vector-ref)
-                                                                 g1054
-                                                                 '2))
-                                                             (g1017
-                                                               ((top-level-value
-                                                                  'vector-ref)
-                                                                 g1054
-                                                                 '3)
-                                                               g1055)))
-                                                         (if ((top-level-value
-                                                                'memv)
-                                                               g1056
-                                                               '(free-id
-                                                                  atom))
-                                                             g1055
-                                                             (if ((top-level-value
-                                                                    'memv)
-                                                                   g1056
-                                                                   '(vector))
-                                                                 (g1017
-                                                                   ((top-level-value
-                                                                      'vector-ref)
-                                                                     g1054
-                                                                     '1)
-                                                                   g1055)
-                                                                 (#%void)))))])
-                                               ((top-level-value
-                                                  'vector-ref)
-                                                 g1054
-                                                 '0))))))])
-                          (case-lambda
-                            [(g1057 g1058)
-                             (if ((top-level-value 'null?)
-                                   ((top-level-value 'car) g1057))
-                                 g1058
-                                 ((top-level-value 'cons)
-                                   ((top-level-value 'map)
-                                     (top-level-value 'car)
-                                     g1057)
-                                   (g1018
-                                     ((top-level-value 'map)
-                                       (top-level-value 'cdr)
-                                       g1057)
-                                     g1058)))])
-                          (case-lambda
-                            [(g1059 g1060 g1061 g1062)
-                             (if ((top-level-value 'null?) g1060)
-                                 (if ((top-level-value 'null?) g1059)
-                                     g1062
-                                     '#f)
-                                 (if ((top-level-value 'pair?) g1060)
-                                     (if ((top-level-value 'pair?) g1059)
-                                         (g1020
-                                           ((top-level-value 'car) g1059)
-                                           ((top-level-value 'car) g1060)
-                                           g1061
-                                           (g1020
-                                             ((top-level-value 'cdr) g1059)
-                                             ((top-level-value 'cdr) g1060)
-                                             g1061
-                                             g1062))
-                                         '#f)
-                                     (if ((top-level-value 'eq?)
-                                           g1060
-                                           'each-any)
-                                         ((case-lambda
-                                            [(g1063)
-                                             (if g1063
-                                                 ((top-level-value 'cons)
-                                                   g1063
-                                                   g1062)
-                                                 '#f)])
-                                           (g1016 g1059 g1061))
-                                         ((case-lambda
-                                            [(g1064)
-                                             (if ((top-level-value 'memv)
-                                                   g1064
-                                                   '(each))
-                                                 (if ((top-level-value
-                                                        'null?)
-                                                       g1059)
-                                                     (g1017
-                                                       ((top-level-value
-                                                          'vector-ref)
-                                                         g1060
-                                                         '1)
-                                                       g1062)
-                                                     ((case-lambda
-                                                        [(g1065)
-                                                         (if g1065
-                                                             (g1018
-                                                               g1065
-                                                               g1062)
-                                                             '#f)])
-                                                       (g1014
-                                                         g1059
-                                                         ((top-level-value
-                                                            'vector-ref)
-                                                           g1060
-                                                           '1)
-                                                         g1061)))
-                                                 (if ((top-level-value
-                                                        'memv)
-                                                       g1064
-                                                       '(free-id))
-                                                     (if (g41 g1059)
-                                                         (if (g112
-                                                               (g119
-                                                                 g1059
-                                                                 g1061)
-                                                               ((top-level-value
-                                                                  'vector-ref)
-                                                                 g1060
-                                                                 '1))
-                                                             g1062
-                                                             '#f)
-                                                         '#f)
-                                                     (if ((top-level-value
-                                                            'memv)
-                                                           g1064
-                                                           '(each+))
-                                                         ((top-level-value
-                                                            'call-with-values)
-                                                           (case-lambda
-                                                             [()
-                                                              (g1015 g1059
-                                                                ((top-level-value
-                                                                   'vector-ref)
-                                                                  g1060
-                                                                  '1)
-                                                                ((top-level-value
-                                                                   'vector-ref)
-                                                                  g1060
-                                                                  '2)
-                                                                ((top-level-value
-                                                                   'vector-ref)
-                                                                  g1060
-                                                                  '3)
-                                                                g1061
-                                                                g1062)])
-                                                           (case-lambda
-                                                             [(g1066 g1067
-                                                               g1068)
-                                                              (if g1068
-                                                                  (if ((top-level-value
-                                                                         'null?)
-                                                                        g1067)
-                                                                      (if ((top-level-value
-                                                                             'null?)
-                                                                            g1066)
-                                                                          (g1017
-                                                                            ((top-level-value
-                                                                               'vector-ref)
-                                                                              g1060
-                                                                              '1)
-                                                                            g1068)
-                                                                          (g1018
-                                                                            g1066
-                                                                            g1068))
-                                                                      '#f)
-                                                                  '#f)]))
-                                                         (if ((top-level-value
-                                                                'memv)
-                                                               g1064
-                                                               '(atom))
-                                                             (if ((top-level-value
-                                                                    'equal?)
-                                                                   ((top-level-value
-                                                                      'vector-ref)
-                                                                     g1060
-                                                                     '1)
-                                                                   (g198
-                                                                     g1059
-                                                                     g1061))
-                                                                 g1062
-                                                                 '#f)
-                                                             (if ((top-level-value
-                                                                    'memv)
-                                                                   g1064
-                                                                   '(vector))
-                                                                 (if ((top-level-value
-                                                                        'vector?)
-                                                                       g1059)
-                                                                     (g1020
-                                                                       ((top-level-value
-                                                                          'vector->list)
-                                                                         g1059)
-                                                                       ((top-level-value
-                                                                          'vector-ref)
-                                                                         g1060
-                                                                         '1)
-                                                                       g1061
-                                                                       g1062)
-                                                                     '#f)
-                                                                 (#%void))))))])
-                                           ((top-level-value 'vector-ref)
-                                             g1060
-                                             '0)))))])
-                          (case-lambda
-                            [(g1069 g1070 g1071 g1072)
-                             (if ((top-level-value 'not) g1072)
-                                 '#f
-                                 (if ((top-level-value 'eq?) g1070 'any)
-                                     ((top-level-value 'cons)
-                                       (g119 g1069 g1071)
-                                       g1072)
-                                     (if (g2 g1069)
-                                         (g1019
-                                           ((case-lambda
-                                              [(g1073)
-                                               (if (g7 g1073)
-                                                   ((top-level-value
-                                                      'annotation-expression)
-                                                     g1073)
-                                                   g1073)])
-                                             (g3 g1069))
-                                           g1070
-                                           (g98 g1071 (g4 g1069))
-                                           g1072)
-                                         (g1019
-                                           ((case-lambda
-                                              [(g1074)
-                                               (if (g7 g1074)
-                                                   ((top-level-value
-                                                      'annotation-expression)
-                                                     g1074)
-                                                   g1074)])
-                                             g1069)
-                                           g1070
-                                           g1071
-                                           g1072))))]))]) (void) (void)
-                      (void) (void) (void) (void) (void))]))))])
-         '"noexpand"
-         (case-lambda
-           [(g1075 g1076)
-            ((top-level-value 'vector) 'syntax-object g1075 g1076)])
-         (case-lambda
-           [(g1077)
-            (if ((top-level-value 'vector?) g1077)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1077)
-                      '3)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1077 '0)
-                      'syntax-object)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1078) ((top-level-value 'vector-ref) g1078 '1)])
-         (case-lambda
-           [(g1079) ((top-level-value 'vector-ref) g1079 '2)])
-         (case-lambda
-           [(g1080 g1081)
-            ((top-level-value 'vector-set!) g1080 '1 g1081)])
-         (case-lambda
-           [(g1082 g1083)
-            ((top-level-value 'vector-set!) g1082 '2 g1083)])
-         (case-lambda [(g1084) '#f])
-         (case-lambda
-           [(g1085)
-            ((top-level-value 'eval)
-              ((top-level-value 'list) g0 g1085))])
-         (case-lambda
-           [(g1086)
-            ((top-level-value 'eval)
-              ((top-level-value 'list) g0 g1086))])
-         (case-lambda
-           [(g1087 g1088)
-            (g8 ((top-level-value 'list)
-                  'set-top-level-value!
-                  ((top-level-value 'list) 'quote g1087)
-                  ((top-level-value 'list) 'quote g1088)))])
-         (case-lambda
-           [(g1089 g1090 g1091)
-            ((top-level-value 'error) g1089 '"~a ~s" g1090 g1091)])
-         (case-lambda
-           [(g1092 g1093)
-            ((top-level-value '$sc-put-cte) g1092 g1093 '*top*)])
-         (case-lambda
-           [(g1094) ((top-level-value 'getprop) g1094 '*sc-expander*)])
-         (case-lambda
-           [(g1095 g1096)
-            (if ((top-level-value 'not) g1096)
-                ((top-level-value 'remprop) g1095 '*sc-expander*)
-                ((top-level-value 'putprop) g1095 '*sc-expander* g1096))])
-         (case-lambda [(g1097) '#f])
-         (case-lambda
-           [(g1098 g1099) ((top-level-value 'getprop) g1098 g1099)])
-         (case-lambda
-           [(g1100 g1101 g1102)
-            (if ((top-level-value 'not) g1102)
-                ((top-level-value 'remprop) g1100 g1101)
-                ((top-level-value 'putprop) g1100 g1101 g1102))])
-         (case-lambda
-           [(g1103)
-            (if g1103
-                ((top-level-value 'gensym)
-                  ((top-level-value 'symbol->string) g1103))
-                ((top-level-value 'gensym)))])
-         (case-lambda
-           [(g1104)
-            (if ((top-level-value 'pair?) g1104)
-                ((top-level-value 'eq?)
-                  ((top-level-value 'car) g1104)
-                  'case-lambda)
-                '#f)])
-         (case-lambda
-           [(g1105 g1106)
-            (((case-lambda
-                [(g1107)
-                 ((case-lambda [(g1108) (begin (set! g1107 g1108) g1107)])
-                   (case-lambda
-                     [(g1109)
-                      (if ((top-level-value 'null?)
-                            ((top-level-value 'cdr) g1109))
-                          ((top-level-value 'car) g1109)
-                          (if ((top-level-value 'equal?)
-                                ((top-level-value 'car) g1109)
-                                '(void))
-                              (g1107 ((top-level-value 'cdr) g1109))
-                              ((top-level-value 'cons) 'begin g1109)))]))])
-               (void))
-              g1106)])
-         (case-lambda
-           [(g1110 g1111 g1112 g1113)
-            (if ((top-level-value 'null?) g1111)
-                g1113
-                ((case-lambda
-                   [(g1114 g1115)
-                    ((top-level-value 'cons)
-                      ((top-level-value 'list)
-                        'case-lambda
-                        ((top-level-value 'list)
-                          g1111
-                          ((top-level-value 'cons)
-                            ((top-level-value 'list)
-                              'case-lambda
-                              ((top-level-value 'list)
-                                g1114
-                                ((top-level-value 'cons)
-                                  'begin
-                                  ((top-level-value 'append)
-                                    ((top-level-value 'map)
-                                      (case-lambda
-                                        [(g1116 g1117)
-                                         ((top-level-value 'list)
-                                           'set!
-                                           g1116
-                                           g1117)])
-                                      g1111
-                                      g1114)
-                                    ((top-level-value 'list) g1113)))))
-                            g1112)))
-                      g1115)])
-                  ((top-level-value 'map)
-                    (case-lambda [(g1118) ((top-level-value 'gensym))])
-                    g1111)
-                  ((top-level-value 'map)
-                    (case-lambda [(g1119) '(void)])
-                    g1111)))])
-         (case-lambda
-           [(g1120 g1121 g1122 g1123) (g21 g1120 g1121 g1122 g1123)])
-         (case-lambda
-           [(g1124 g1125 g1126 g1127 g1128)
-            ((top-level-value 'call-with-values)
-              (case-lambda
-                [()
-                 (((case-lambda
-                     [(g1129)
-                      ((case-lambda
-                         [(g1130) (begin (set! g1129 g1130) g1129)])
-                        (case-lambda
-                          [(g1131 g1132)
-                           (if ((top-level-value 'null?) g1131)
-                               ((top-level-value 'values) '() '() '())
-                               ((case-lambda
-                                  [(g1133)
-                                   ((top-level-value 'call-with-values)
-                                     (case-lambda
-                                       [()
-                                        (g1129
-                                          ((top-level-value 'cdr) g1131)
-                                          ((top-level-value 'cdr) g1132))])
-                                     (case-lambda
-                                       [(g1134 g1135 g1136)
-                                        (if ((top-level-value 'eq?)
-                                              ((top-level-value 'car)
-                                                g1131)
-                                              'global)
-                                            ((case-lambda
-                                               [(g1137)
-                                                ((top-level-value 'values)
-                                                  ((top-level-value 'cons)
-                                                    g1137
-                                                    g1134)
-                                                  ((top-level-value 'cons)
-                                                    ((top-level-value
-                                                       'list)
-                                                      'set-top-level-value!
-                                                      ((top-level-value
-                                                         'list)
-                                                        'quote
-                                                        g1133)
-                                                      (g194))
-                                                    g1135)
-                                                  ((top-level-value 'cons)
-                                                    ((top-level-value
-                                                       'list)
-                                                      'set-top-level-value!
-                                                      ((top-level-value
-                                                         'list)
-                                                        'quote
-                                                        g1133)
-                                                      g1137)
-                                                    g1136))])
-                                              ((top-level-value 'gensym)))
-                                            ((top-level-value 'values)
-                                              ((top-level-value 'cons)
-                                                g1133
-                                                g1134)
-                                              g1135
-                                              g1136))]))])
-                                 ((top-level-value 'car) g1132)))]))])
-                    (void))
-                   g1125
-                   g1126)])
-              (case-lambda
-                [(g1138 g1139 g1140)
-                 (if ((top-level-value 'null?) g1139)
-                     (g21 g1124 g1138 g1127 g1128)
-                     (g20 '#f
-                          ((top-level-value 'append)
-                            g1139
-                            ((top-level-value 'list)
-                              (g21 g1124
-                                   g1138
-                                   g1127
-                                   (g20 '#f
-                                        ((top-level-value 'append)
-                                          g1140
-                                          ((top-level-value 'list)
-                                            g1128))))))))]))])
-         (case-lambda
-           [(g1141)
-            (if ((top-level-value 'procedure?) g1141)
-                ((top-level-value 'cons) 'macro g1141)
-                (if (g29 g1141)
-                    (if ((case-lambda
-                           [(g1142)
-                            (if ((top-level-value 'memv)
-                                  g1142
-                                  '(core macro macro! deferred))
-                                ((top-level-value 'procedure?) (g26 g1141))
-                                (if ((top-level-value 'memv)
-                                      g1142
-                                      '($module))
-                                    (g128 (g26 g1141))
-                                    (if ((top-level-value 'memv)
-                                          g1142
-                                          '(lexical))
-                                        '#f
-                                        (if ((top-level-value 'memv)
-                                              g1142
-                                              '(global meta-variable))
-                                            ((top-level-value 'symbol?)
-                                              (g26 g1141))
-                                            (if ((top-level-value 'memv)
-                                                  g1142
-                                                  '(syntax))
-                                                ((case-lambda
-                                                   [(g1143)
-                                                    (if ((top-level-value
-                                                           'pair?)
-                                                          g1143)
-                                                        (if '#f
-                                                            ((case-lambda
-                                                               [(g1144)
-                                                                (if ((top-level-value
-                                                                       'integer?)
-                                                                      g1144)
-                                                                    (if ((top-level-value
-                                                                           'exact?)
-                                                                          g1144)
-                                                                        ((top-level-value
-                                                                           'fx>=)
-                                                                          g1144
-                                                                          '0)
-                                                                        '#f)
-                                                                    '#f)])
-                                                              ((top-level-value
-                                                                 'cdr)
-                                                                g1143))
-                                                            '#f)
-                                                        '#f)])
-                                                  (g26 g1141))
-                                                (if ((top-level-value
-                                                       'memv)
-                                                      g1142
-                                                      '(begin
-                                                         define
-                                                         define-syntax
-                                                         set!
-                                                         $module-key
-                                                         $import
-                                                         eval-when
-                                                         meta))
-                                                    ((top-level-value
-                                                       'null?)
-                                                      (g26 g1141))
-                                                    (if ((top-level-value
-                                                           'memv)
-                                                          g1142
-                                                          '(local-syntax))
-                                                        ((top-level-value
-                                                           'boolean?)
-                                                          (g26 g1141))
-                                                        (if ((top-level-value
-                                                               'memv)
-                                                              g1142
-                                                              '(displaced-lexical))
-                                                            ((top-level-value
-                                                               'eq?)
-                                                              (g26 g1141)
-                                                              '#f)
-                                                            '#t))))))))])
-                          (g25 g1141))
-                        g1141
-                        '#f)
-                    '#f))])
-         (top-level-value 'car) (top-level-value 'cdr)
-         (top-level-value 'set-car!) (top-level-value 'set-cdr!)
-         (case-lambda
-           [(g1145)
-            (if ((top-level-value 'pair?) g1145)
-                ((top-level-value 'symbol?) ((top-level-value 'car) g1145))
-                '#f)])
-         (case-lambda
-           [(g1146 g1147 g1148)
-            ((top-level-value 'cons)
-              ((top-level-value 'cons) g1146 g1147)
-              g1148)])
-         (case-lambda
-           [(g1149 g1150 g1151)
-            (if ((top-level-value 'null?) g1149)
-                g1151
-                (g31 ((top-level-value 'cdr) g1149)
-                     ((top-level-value 'cdr) g1150)
-                     (g30 ((top-level-value 'car) g1149)
-                          ((top-level-value 'car) g1150)
-                          g1151)))])
-         (case-lambda
-           [(g1152 g1153 g1154)
-            (if ((top-level-value 'null?) g1152)
-                g1154
-                (g32 ((top-level-value 'cdr) g1152)
-                     ((top-level-value 'cdr) g1153)
-                     (g30 ((top-level-value 'car) g1152)
-                          ((top-level-value 'cons)
-                            'lexical
-                            ((top-level-value 'car) g1153))
-                          g1154)))])
-         (case-lambda
-           [(g1155 g1156)
-            ((case-lambda
-               [(g1157)
-                (if g1157
-                    ((case-lambda
-                       [(g1158)
-                        ((top-level-value 'eq?)
-                          (g25 g1158)
-                          'displaced-lexical)])
-                      (g36 g1157 g1156))
-                    '#f)])
-              (g110 g1155 '(())))])
-         (case-lambda
-           [(g1159)
-            ((top-level-value 'syntax-error)
-              g1159
-              (if (g110 g1159 '(()))
-                  '"identifier out of context"
-                  '"identifier not visible"))])
-         (case-lambda
-           [(g1160 g1161)
-            ((case-lambda
-               [(g1162)
-                (if g1162
-                    ((top-level-value 'cdr) g1162)
-                    (if ((top-level-value 'symbol?) g1160)
-                        ((case-lambda
-                           [(g1163)
-                            (if g1163
-                                g1163
-                                ((top-level-value 'cons) 'global g1160))])
-                          (g13 g1160))
-                        '(displaced-lexical . #f)))])
-              ((top-level-value 'assq) g1160 g1161))])
-         (case-lambda
-           [(g1164 g1165)
-            ((case-lambda
-               [(g1166)
-                ((case-lambda
-                   [(g1167)
-                    (begin
-                      (set! g1166 g1167)
-                      ((case-lambda
-                         [(g1168)
-                          (begin
-                            (if ((top-level-value 'eq?)
-                                  (g25 g1168)
-                                  'deferred)
-                                (g1166 g1168 (g37 ((g26 g1168))))
-                                (#%void))
-                            g1168)])
-                        (g35 g1164 g1165)))])
-                  (case-lambda
-                    [(g1169 g1170)
-                     (begin
-                       (g27 g1169 (g25 g1170))
-                       (g28 g1169 (g26 g1170)))]))])
-              (void))])
-         (case-lambda
-           [(g1171)
-            ((case-lambda
-               [(g1172)
-                (if g1172
-                    g1172
-                    ((top-level-value 'syntax-error)
-                      g1171
-                      '"invalid transformer"))])
-              (g24 g1171))])
-         (case-lambda
-           [(g1173 g1174)
-            (if (g19 g1174)
-                ((top-level-value 'cons)
-                  'deferred
-                  (case-lambda [() (g1173 g1174)]))
-                (g37 (g1173 g1174)))])
-         (case-lambda
-           [(g1175 g1176 g1177)
-            (g12 g1176 ((top-level-value 'cons) g1175 g1177))])
-         (case-lambda
-           [(g1178)
-            (if (g2 g1178)
-                ((top-level-value 'symbol?)
-                  ((case-lambda
-                     [(g1179)
-                      (if (g7 g1179)
-                          ((top-level-value 'annotation-expression) g1179)
-                          g1179)])
-                    (g3 g1178)))
-                '#f)])
-         (case-lambda
-           [(g1180)
-            (if ((top-level-value 'symbol?) g1180)
-                '#t
-                (if (g2 g1180)
-                    ((top-level-value 'symbol?)
-                      ((case-lambda
-                         [(g1181)
-                          (if (g7 g1181)
-                              ((top-level-value 'annotation-expression)
-                                g1181)
-                              g1181)])
-                        (g3 g1180)))
-                    (if (g7 g1180)
-                        ((top-level-value 'symbol?)
-                          ((top-level-value 'annotation-expression) g1180))
-                        '#f)))])
-         (case-lambda
-           [(g1182) (if (g2 g1182) (g46 (g4 g1182)) (g46 '((top))))])
-         (case-lambda
-           [(g1183) (if (g2 g1183) (g47 (g4 g1183)) (g46 '((top))))])
-         (case-lambda
-           [(g1184 g1185)
-            (if (g2 g1184)
-                ((top-level-value 'values)
-                  ((case-lambda
-                     [(g1186)
-                      (if (g7 g1186)
-                          ((top-level-value 'annotation-expression) g1186)
-                          g1186)])
-                    (g3 g1184))
-                  (g99 (g46 g1185) (g46 (g4 g1184))))
-                ((top-level-value 'values)
-                  ((case-lambda
-                     [(g1187)
-                      (if (g7 g1187)
-                          ((top-level-value 'annotation-expression) g1187)
-                          g1187)])
-                    g1184)
-                  (g46 g1185)))])
-         (top-level-value 'cons) (top-level-value 'car)
-         (top-level-value 'cdr)
-         (case-lambda
-           [(g1188) ((top-level-value 'vector) 'indirect-label g1188)])
-         (case-lambda
-           [(g1189)
-            (if ((top-level-value 'vector?) g1189)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1189)
-                      '2)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1189 '0)
-                      'indirect-label)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1190) ((top-level-value 'vector-ref) g1190 '1)])
-         (case-lambda
-           [(g1191 g1192)
-            ((top-level-value 'vector-set!) g1191 '1 g1192)])
-         (case-lambda [() (g48 (g55))])
-         (case-lambda [(g1193) (g50 g1193)])
-         (case-lambda [(g1194 g1195) (g51 g1194 g1195)])
-         (case-lambda [() ((top-level-value 'string) '#\i)])
-         (case-lambda
-           [(g1196)
-            ((case-lambda
-               [(g1197)
-                (if g1197
-                    g1197
-                    ((case-lambda [(g1198) (if g1198 g1198 (g49 g1196))])
-                      ((top-level-value 'symbol?) g1196)))])
-              ((top-level-value 'string?) g1196))])
-         (case-lambda
-           [(g1199)
-            (if ((top-level-value 'null?) g1199)
-                '()
-                ((top-level-value 'cons)
-                  (g55)
-                  (g57 ((top-level-value 'cdr) g1199))))])
-         (case-lambda
-           [(g1200 g1201 g1202)
-            ((top-level-value 'vector) 'ribcage g1200 g1201 g1202)])
-         (case-lambda
-           [(g1203)
-            (if ((top-level-value 'vector?) g1203)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1203)
-                      '4)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1203 '0)
-                      'ribcage)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1204) ((top-level-value 'vector-ref) g1204 '1)])
-         (case-lambda
-           [(g1205) ((top-level-value 'vector-ref) g1205 '2)])
-         (case-lambda
-           [(g1206) ((top-level-value 'vector-ref) g1206 '3)])
-         (case-lambda
-           [(g1207 g1208)
-            ((top-level-value 'vector-set!) g1207 '1 g1208)])
-         (case-lambda
-           [(g1209 g1210)
-            ((top-level-value 'vector-set!) g1209 '2 g1210)])
-         (case-lambda
-           [(g1211 g1212)
-            ((top-level-value 'vector-set!) g1211 '3 g1212)])
-         (case-lambda
-           [(g1213 g1214)
-            ((top-level-value 'vector) 'top-ribcage g1213 g1214)])
-         (case-lambda
-           [(g1215)
-            (if ((top-level-value 'vector?) g1215)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1215)
-                      '3)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1215 '0)
-                      'top-ribcage)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1216) ((top-level-value 'vector-ref) g1216 '1)])
-         (case-lambda
-           [(g1217) ((top-level-value 'vector-ref) g1217 '2)])
-         (case-lambda
-           [(g1218 g1219)
-            ((top-level-value 'vector-set!) g1218 '1 g1219)])
-         (case-lambda
-           [(g1220 g1221)
-            ((top-level-value 'vector-set!) g1220 '2 g1221)])
-         (case-lambda
-           [(g1222 g1223)
-            ((top-level-value 'vector) 'import-interface g1222 g1223)])
-         (case-lambda
-           [(g1224)
-            (if ((top-level-value 'vector?) g1224)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1224)
-                      '3)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1224 '0)
-                      'import-interface)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1225) ((top-level-value 'vector-ref) g1225 '1)])
-         (case-lambda
-           [(g1226) ((top-level-value 'vector-ref) g1226 '2)])
-         (case-lambda
-           [(g1227 g1228)
-            ((top-level-value 'vector-set!) g1227 '1 g1228)])
-         (case-lambda
-           [(g1229 g1230)
-            ((top-level-value 'vector-set!) g1229 '2 g1230)])
-         (case-lambda
-           [(g1231 g1232)
-            ((top-level-value 'vector) 'env g1231 g1232)])
-         (case-lambda
-           [(g1233)
-            (if ((top-level-value 'vector?) g1233)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1233)
-                      '3)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1233 '0)
-                      'env)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1234) ((top-level-value 'vector-ref) g1234 '1)])
-         (case-lambda
-           [(g1235) ((top-level-value 'vector-ref) g1235 '2)])
-         (case-lambda
-           [(g1236 g1237)
-            ((top-level-value 'vector-set!) g1236 '1 g1237)])
-         (case-lambda
-           [(g1238 g1239)
-            ((top-level-value 'vector-set!) g1238 '2 g1239)])
-         (case-lambda
-           [(g1240)
-            (g45 ((top-level-value 'cons) '#f (g46 g1240))
-                 ((top-level-value 'cons) 'shift (g47 g1240)))])
-         '#f
-         (case-lambda
-           [(g1241 g1242 g1243)
-            (begin
-              (g63 g1241
-                   ((top-level-value 'cons)
-                     ((case-lambda
-                        [(g1244)
-                         (if (g7 g1244)
-                             ((top-level-value 'annotation-expression)
-                               g1244)
-                             g1244)])
-                       (g3 g1242))
-                     (g60 g1241)))
-              (g64 g1241
-                   ((top-level-value 'cons) (g46 (g4 g1242)) (g61 g1241)))
-              (g65 g1241 ((top-level-value 'cons) g1243 (g62 g1241))))])
-         (case-lambda
-           [(g1245 g1246 g1247 g1248)
-            (begin
-              (g63 g1245
-                   ((top-level-value 'cons)
-                     ((case-lambda
-                        [(g1249)
-                         (if (g7 g1249)
-                             ((top-level-value 'annotation-expression)
-                               g1249)
-                             g1249)])
-                       (g3 g1247))
-                     (g60 g1245)))
-              (g64 g1245
-                   ((top-level-value 'cons)
-                     (g99 g1246 (g46 (g4 g1247)))
-                     (g61 g1245)))
-              (g65 g1245 ((top-level-value 'cons) g1248 (g62 g1245))))])
-         (case-lambda [(g1250 g1251) (g89 g1250 (g4 g1251))])
-         (case-lambda
-           [(g1252 g1253)
-            (begin
-              (g63 g1252 ((top-level-value 'cons) g85 (g60 g1252)))
-              (g64 g1252
-                   ((top-level-value 'cons) (g46 g1253) (g61 g1252))))])
-         (case-lambda
-           [(g1254 g1255)
-            (g63 g1254 ((top-level-value 'cons) g1255 (g60 g1254)))])
-         (case-lambda
-           [(g1256 g1257 g1258 g1259)
-            ((case-lambda
-               [(g1260)
-                (if g1260
-                    (((case-lambda
-                        [(g1261)
-                         ((case-lambda
-                            [(g1262) (begin (set! g1261 g1262) g1261)])
-                           (case-lambda
-                             [(g1263)
-                              (if ((top-level-value 'pair?) g1263)
-                                  ((case-lambda
-                                     [(g1264)
-                                      (if g1264
-                                          g1264
-                                          (g1261
-                                            ((top-level-value 'cdr)
-                                              g1263)))])
-                                    (g1261 ((top-level-value 'car) g1263)))
-                                  (if ((top-level-value 'symbol?) g1263)
-                                      (if (g101
-                                            g1257
-                                            (g99 g1259 (g46 '((top)))))
-                                          g1263
-                                          '#f)
-                                      (if (g101
-                                            g1257
-                                            (g99 g1259 (g46 (g4 g1263))))
-                                          g1263
-                                          '#f)))]))])
-                       (void))
-                      g1260)
-                    '#f)])
-              (g16 g1256 g1258))])
-         (case-lambda
-           [(g1265 g1266 g1267)
-            ((case-lambda
-               [(g1268 g1269)
-                ((case-lambda
-                   [(g1270 g1271)
-                    (begin
-                      (set! g1268 g1270)
-                      (set! g1269 g1271)
-                      ((case-lambda
-                         [(g1272)
-                          ((case-lambda
-                             [(g1273)
-                              (if ((top-level-value 'not)
-                                    ((top-level-value 'eq?) g1272 g1273))
-                                  ((case-lambda
-                                     [(g1274)
-                                      ((case-lambda
-                                         [(g1275)
-                                          (g17 g1273
-                                               g1266
-                                               (g1268
-                                                 (if (g101
-                                                       g1274
-                                                       (g46 '((top))))
-                                                     (g96 g1272)
-                                                     g1272)
-                                                 g1275))])
-                                        (g1269 g1274 (g16 g1273 g1266)))])
-                                    (g42 g1272))
-                                  (#%void))])
-                            ((case-lambda
-                               [(g1276)
-                                ((case-lambda
-                                   [(g1277)
-                                    (if (g7 g1277)
-                                        ((top-level-value
-                                           'annotation-expression)
-                                          g1277)
-                                        g1277)])
-                                  (if (g2 g1276) (g3 g1276) g1276))])
-                              g1272))])
-                        (if ((top-level-value 'null?) g1267)
-                            g1265
-                            (g1 ((case-lambda
-                                   [(g1278)
-                                    ((case-lambda
-                                       [(g1279)
-                                        (if (g7 g1279)
-                                            ((top-level-value
-                                               'annotation-expression)
-                                              g1279)
-                                            g1279)])
-                                      (if (g2 g1278) (g3 g1278) g1278))])
-                                  g1265)
-                                (g45 (g99 g1267 (g42 g1265))
-                                     (g43 g1265))))))])
-                  (case-lambda
-                    [(g1280 g1281)
-                     (if ((top-level-value 'not) g1281)
-                         g1280
-                         ((top-level-value 'cons) g1280 g1281))])
-                  (case-lambda
-                    [(g1282 g1283)
-                     (if ((top-level-value 'pair?) g1283)
-                         (if (g101
-                               (g42 ((top-level-value 'car) g1283))
-                               g1282)
-                             (g1269 g1282 ((top-level-value 'cdr) g1283))
-                             (g1268
-                               ((top-level-value 'car) g1283)
-                               (g1269
-                                 g1282
-                                 ((top-level-value 'cdr) g1283))))
-                         (if g1283
-                             (if ((top-level-value 'not)
-                                   (g101 (g42 g1283) g1282))
-                                 g1283
-                                 '#f)
-                             '#f))]))])
-              (void)
-              (void))])
-         (case-lambda
-           [(g1284 g1285 g1286)
-            (if ((top-level-value 'null?) g1284)
-                g1286
-                (g45 (g46 g1286)
-                     ((top-level-value 'cons)
-                       ((case-lambda
-                          [(g1287)
-                           ((case-lambda
-                              [(g1288)
-                               ((case-lambda
-                                  [(g1289 g1290)
-                                   (begin
-                                     (((case-lambda
-                                         [(g1291)
-                                          ((case-lambda
-                                             [(g1292)
-                                              (begin
-                                                (set! g1291 g1292)
-                                                g1291)])
-                                            (case-lambda
-                                              [(g1293 g1294)
-                                               (if ((top-level-value 'not)
-                                                     ((top-level-value
-                                                        'null?)
-                                                       g1293))
-                                                   ((top-level-value
-                                                      'call-with-values)
-                                                     (case-lambda
-                                                       [()
-                                                        (g44 ((top-level-value
-                                                                'car)
-                                                               g1293)
-                                                             g1286)])
-                                                     (case-lambda
-                                                       [(g1295 g1296)
-                                                        (begin
-                                                          ((top-level-value
-                                                             'vector-set!)
-                                                            g1289
-                                                            g1294
-                                                            g1295)
-                                                          ((top-level-value
-                                                             'vector-set!)
-                                                            g1290
-                                                            g1294
-                                                            g1296)
-                                                          (g1291
-                                                            ((top-level-value
-                                                               'cdr)
-                                                              g1293)
-                                                            ((top-level-value
-                                                               'fx+)
-                                                              g1294
-                                                              '1)))]))
-                                                   (#%void))]))])
-                                        (void))
-                                       g1284
-                                       '0)
-                                     (g58 g1289 g1290 g1287))])
-                                 ((top-level-value 'make-vector) g1288)
-                                 ((top-level-value 'make-vector) g1288))])
-                             ((top-level-value 'vector-length) g1287))])
-                         ((top-level-value 'list->vector) g1285))
-                       (g47 g1286))))])
-         (case-lambda
-           [(g1297 g1298 g1299)
-            (g1 g1297
-                (g45 g1298
-                     ((top-level-value 'list)
-                       (g58 ((top-level-value 'vector) g1297)
-                            ((top-level-value 'vector) g1298)
-                            ((top-level-value 'vector) g1299)))))])
-         (case-lambda
-           [(g1300)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g108 g1300 '(()))])
-              (case-lambda
-                [(g1301 g1302)
-                 (begin
-                   (if ((top-level-value 'not) g1301)
-                       ((top-level-value 'syntax-error)
-                         g1300
-                         '"identifier not visible for export")
-                       (#%void))
-                   (g94 ((case-lambda
-                           [(g1303)
-                            ((case-lambda
-                               [(g1304)
-                                (if (g7 g1304)
-                                    ((top-level-value
-                                       'annotation-expression)
-                                      g1304)
-                                    g1304)])
-                              (if (g2 g1303) (g3 g1303) g1303))])
-                          g1300)
-                        g1302
-                        g1301))]))])
-         (case-lambda
-           [(g1305)
-            ((top-level-value 'vector-ref)
-              (g62 ((top-level-value 'car) (g47 (g4 g1305))))
-              '0)])
-         (case-lambda
-           [(g1306 g1307)
-            (if ((top-level-value 'null?) g1307)
-                g1306
-                ((top-level-value 'append) g1306 g1307))])
-         (case-lambda
-           [(g1308 g1309)
-            ((case-lambda
-               [(g1310 g1311)
-                (if ((top-level-value 'null?) g1310)
-                    (if ((top-level-value 'null?) g1311)
-                        g1309
-                        (g45 (g46 g1309) (g100 g1311 (g47 g1309))))
-                    (g45 (g99 g1310 (g46 g1309))
-                         (g100 g1311 (g47 g1309))))])
-              (g46 g1308)
-              (g47 g1308))])
-         (case-lambda [(g1312 g1313) (g97 g1312 g1313)])
-         (case-lambda [(g1314 g1315) (g97 g1314 g1315)])
-         (case-lambda
-           [(g1316 g1317)
-            ((case-lambda
-               [(g1318)
-                (if g1318
-                    g1318
-                    (if ((top-level-value 'not)
-                          ((top-level-value 'null?) g1316))
-                        (if ((top-level-value 'not)
-                              ((top-level-value 'null?) g1317))
-                            (if ((top-level-value 'eq?)
-                                  ((top-level-value 'car) g1316)
-                                  ((top-level-value 'car) g1317))
-                                (g101
-                                  ((top-level-value 'cdr) g1316)
-                                  ((top-level-value 'cdr) g1317))
-                                '#f)
-                            '#f)
-                        '#f))])
-              ((top-level-value 'eq?) g1316 g1317))])
-         (case-lambda
-           [(g1319 g1320)
-            ((case-lambda
-               [(g1321 g1322)
-                (((case-lambda
-                    [(g1323)
-                     ((case-lambda
-                        [(g1324) (begin (set! g1323 g1324) g1323)])
-                       (case-lambda
-                         [(g1325 g1326)
-                          (if ((top-level-value 'fx>) g1325 g1322)
-                              ((top-level-value 'cons)
-                                ((top-level-value 'car) g1326)
-                                (g1323
-                                  ((top-level-value 'fx-) g1325 '1)
-                                  ((top-level-value 'cdr) g1326)))
-                              (if ((top-level-value 'equal?) g1326 g1320)
-                                  '()
-                                  ((top-level-value 'error)
-                                    'sc-expand
-                                    '"internal error in diff-marks: ~s is not a tail of ~s"
-                                    g1326
-                                    g1320)))]))])
-                   (void))
-                  g1321
-                  g1319)])
-              ((top-level-value 'length) g1319)
-              ((top-level-value 'length) g1320))])
-         (case-lambda
-           [(g1327) ((top-level-value 'eq?) g1327 '*top*)])
-         (case-lambda
-           [(g1328 g1329 g1330)
-            ((case-lambda
-               [(g1331)
-                ((case-lambda
-                   [(g1332)
-                    (begin
-                      (g92 g1332 g1330 '())
-                      ((top-level-value 'values) g1331 g1332))])
-                  (g94 g1328 g1329 g1331))])
-              (if (if (g103 g1330) (g101 g1329 (g46 '((top)))) '#f)
-                  g1328
-                  (g18 g1328)))])
-         (case-lambda
-           [(g1333 g1334 g1335)
-            ((case-lambda
-               [(g1336)
-                ((case-lambda
-                   [(g1337)
-                    (if g1337
-                        ((case-lambda
-                           [(g1338)
-                            (if ((top-level-value 'symbol?) g1338)
-                                (if (g15 g1338)
-                                    (g104 g1333 g1334 g1336)
-                                    ((top-level-value 'values)
-                                      g1338
-                                      (g94 g1333 g1334 g1338)))
-                                ((top-level-value 'values)
-                                  (g96 g1338)
-                                  g1338))])
-                          g1337)
-                        (g104 g1333 g1334 g1336))])
-                  (g91 g1333 g1334 g1336 '()))])
-              (g68 g1335))])
-         (case-lambda
-           [(g1339 g1340 g1341)
-            ((case-lambda
-               [(g1342)
-                ((case-lambda
-                   [(g1343)
-                    (if g1343
-                        ((case-lambda
-                           [(g1344)
-                            (if ((top-level-value 'symbol?) g1344)
-                                g1344
-                                (g96 g1344))])
-                          g1343)
-                        (if (if (g69 g1341)
-                                (g101 g1340 (g46 '((top))))
-                                '#f)
-                            ((top-level-value 'call-with-values)
-                              (case-lambda
-                                [() (g104 g1339 (g46 '((top))) g1342)])
-                              (case-lambda [(g1345 g1346) g1345]))
-                            '#f))])
-                  (g91 g1339 g1340 g1342 '()))])
-              (g68 g1341))])
-         (case-lambda
-           [(g1347 g1348)
-            ((case-lambda
-               [(g1349 g1350 g1351)
-                ((case-lambda
-                   [(g1352 g1353 g1354)
-                    (begin
-                      (set! g1349 g1352)
-                      (set! g1350 g1353)
-                      (set! g1351 g1354)
-                      (if ((top-level-value 'symbol?) g1347)
-                          (g1349 g1347 (g47 g1348) (g46 g1348))
-                          (if (g2 g1347)
-                              ((case-lambda
-                                 [(g1355 g1356)
-                                  ((top-level-value 'call-with-values)
-                                    (case-lambda
-                                      [()
-                                       (g1349
-                                         g1355
-                                         (g47 g1348)
-                                         (g99 (g46 g1348) (g46 g1356)))])
-                                    (case-lambda
-                                      [(g1357 g1358)
-                                       (if g1357
-                                           ((top-level-value 'values)
-                                             g1357
-                                             g1358)
-                                           (g1349
-                                             g1355
-                                             (g47 g1356)
-                                             g1358))]))])
-                                ((case-lambda
-                                   [(g1359)
-                                    (if (g7 g1359)
-                                        ((top-level-value
-                                           'annotation-expression)
-                                          g1359)
-                                        g1359)])
-                                  (g3 g1347))
-                                (g4 g1347))
-                              (if (g7 g1347)
-                                  (g1349
-                                    ((case-lambda
-                                       [(g1360)
-                                        (if (g7 g1360)
-                                            ((top-level-value
-                                               'annotation-expression)
-                                              g1360)
-                                            g1360)])
-                                      g1347)
-                                    (g47 g1348)
-                                    (g46 g1348))
-                                  (g11 'id-var-name
-                                       '"invalid id"
-                                       g1347)))))])
-                  (case-lambda
-                    [(g1361 g1362 g1363)
-                     (if ((top-level-value 'null?) g1362)
-                         ((top-level-value 'values) '#f g1363)
-                         ((case-lambda
-                            [(g1364)
-                             (if ((top-level-value 'eq?) g1364 'shift)
-                                 (g1349
-                                   g1361
-                                   ((top-level-value 'cdr) g1362)
-                                   ((top-level-value 'cdr) g1363))
-                                 (if (g59 g1364)
-                                     ((case-lambda
-                                        [(g1365)
-                                         (if ((top-level-value 'vector?)
-                                               g1365)
-                                             (g1351 g1361 g1362 g1363 g1365
-                                               g1364)
-                                             (g1350 g1361 g1362 g1363 g1365
-                                               g1364))])
-                                       (g60 g1364))
-                                     (if (g67 g1364)
-                                         ((case-lambda
-                                            [(g1366)
-                                             (if g1366
-                                                 ((case-lambda
-                                                    [(g1367)
-                                                     ((top-level-value
-                                                        'values)
-                                                       g1367
-                                                       g1363)])
-                                                   g1366)
-                                                 (g1349
-                                                   g1361
-                                                   ((top-level-value 'cdr)
-                                                     g1362)
-                                                   g1363))])
-                                           (g106 g1361 g1363 g1364))
-                                         ((top-level-value 'error)
-                                           'sc-expand
-                                           '"internal error in id-var-name-loc&marks: improper subst ~s"
-                                           g1362))))])
-                           ((top-level-value 'car) g1362)))])
-                  (case-lambda
-                    [(g1368 g1369 g1370 g1371 g1372)
-                     (((case-lambda
-                         [(g1373)
-                          ((case-lambda
-                             [(g1374) (begin (set! g1373 g1374) g1373)])
-                            (case-lambda
-                              [(g1375 g1376)
-                               (if ((top-level-value 'null?) g1375)
-                                   (g1349
-                                     g1368
-                                     ((top-level-value 'cdr) g1369)
-                                     g1370)
-                                   ((case-lambda
-                                      [(g1377)
-                                       (if (if ((top-level-value 'eq?)
-                                                 g1377
-                                                 g1368)
-                                               (g101
-                                                 g1370
-                                                 ((top-level-value
-                                                    'list-ref)
-                                                   (g61 g1372)
-                                                   g1376))
-                                               '#f)
-                                           ((top-level-value 'values)
-                                             ((top-level-value 'list-ref)
-                                               (g62 g1372)
-                                               g1376)
-                                             g1370)
-                                           (if (g73 g1377)
-                                               ((case-lambda
-                                                  [(g1378 g1379)
-                                                   ((case-lambda
-                                                      [(g1380)
-                                                       (if g1380
-                                                           ((case-lambda
-                                                              [(g1381)
-                                                               ((case-lambda
-                                                                  [(g1382)
-                                                                   (if g1382
-                                                                       ((case-lambda
-                                                                          [(g1383)
-                                                                           ((top-level-value
-                                                                              'values)
-                                                                             (if ((top-level-value
-                                                                                    'symbol?)
-                                                                                   g1383)
-                                                                                 g1383
-                                                                                 (g96 g1383))
-                                                                             g1370)])
-                                                                         g1382)
-                                                                       (g1373
-                                                                         ((top-level-value
-                                                                            'cdr)
-                                                                           g1375)
-                                                                         g1376))])
-                                                                 (g91 g1368
-                                                                      g1370
-                                                                      g1381
-                                                                      g1379))])
-                                                             g1380)
-                                                           ((case-lambda
-                                                              [(g1384)
-                                                               ((case-lambda
-                                                                  [(g1385)
-                                                                   ((case-lambda
-                                                                      [()
-                                                                       (((case-lambda
-                                                                           [(g1386)
-                                                                            ((case-lambda
-                                                                               [(g1387)
-                                                                                (begin
-                                                                                  (set! g1386
-                                                                                    g1387)
-                                                                                  g1386)])
-                                                                              (case-lambda
-                                                                                [(g1388)
-                                                                                 (if ((top-level-value
-                                                                                        'fx=)
-                                                                                       g1388
-                                                                                       g1385)
-                                                                                     (g1373
-                                                                                       ((top-level-value
-                                                                                          'cdr)
-                                                                                         g1375)
-                                                                                       g1376)
-                                                                                     ((case-lambda
-                                                                                        [(g1389)
-                                                                                         ((case-lambda
-                                                                                            [(g1390
-                                                                                              g1391)
-                                                                                             (if (g113
-                                                                                                   g1390
-                                                                                                   g1391
-                                                                                                   g1368
-                                                                                                   g1370)
-                                                                                                 ((top-level-value
-                                                                                                    'values)
-                                                                                                   (g182
-                                                                                                     g1389)
-                                                                                                   g1370)
-                                                                                                 (g1386
-                                                                                                   ((top-level-value
-                                                                                                      'fx+)
-                                                                                                     g1388
-                                                                                                     '1)))])
-                                                                                           ((case-lambda
-                                                                                              [(g1392)
-                                                                                               ((case-lambda
-                                                                                                  [(g1393)
-                                                                                                   (if (g7 g1393)
-                                                                                                       ((top-level-value
-                                                                                                          'annotation-expression)
-                                                                                                         g1393)
-                                                                                                       g1393)])
-                                                                                                 (if (g2 g1392)
-                                                                                                     (g3 g1392)
-                                                                                                     g1392))])
-                                                                                             g1389)
-                                                                                           (g99 g1379
-                                                                                                (g42 g1389)))])
-                                                                                       ((top-level-value
-                                                                                          'vector-ref)
-                                                                                         g1384
-                                                                                         g1388)))]))])
-                                                                          (void))
-                                                                         '0)]))])
-                                                                 ((top-level-value
-                                                                    'vector-length)
-                                                                   g1384))])
-                                                             (g130
-                                                               g1378)))])
-                                                     (g131 g1378))])
-                                                 (g74 g1377)
-                                                 (g75 g1377))
-                                               (if (if ((top-level-value
-                                                          'eq?)
-                                                         g1377
-                                                         g85)
-                                                       (g101
-                                                         g1370
-                                                         ((top-level-value
-                                                            'list-ref)
-                                                           (g61 g1372)
-                                                           g1376))
-                                                       '#f)
-                                                   ((top-level-value
-                                                      'values)
-                                                     '#f
-                                                     g1370)
-                                                   (g1373
-                                                     ((top-level-value
-                                                        'cdr)
-                                                       g1375)
-                                                     ((top-level-value
-                                                        'fx+)
-                                                       g1376
-                                                       '1)))))])
-                                     ((top-level-value 'car) g1375)))]))])
-                        (void))
-                       g1371
-                       '0)])
-                  (case-lambda
-                    [(g1394 g1395 g1396 g1397 g1398)
-                     ((case-lambda
-                        [(g1399)
-                         (((case-lambda
-                             [(g1400)
-                              ((case-lambda
-                                 [(g1401)
-                                  (begin (set! g1400 g1401) g1400)])
-                                (case-lambda
-                                  [(g1402)
-                                   (if ((top-level-value 'fx=) g1402 g1399)
-                                       (g1349
-                                         g1394
-                                         ((top-level-value 'cdr) g1395)
-                                         g1396)
-                                       (if (if ((top-level-value 'eq?)
-                                                 ((top-level-value
-                                                    'vector-ref)
-                                                   g1397
-                                                   g1402)
-                                                 g1394)
-                                               (g101
-                                                 g1396
-                                                 ((top-level-value
-                                                    'vector-ref)
-                                                   (g61 g1398)
-                                                   g1402))
-                                               '#f)
-                                           ((top-level-value 'values)
-                                             ((top-level-value 'vector-ref)
-                                               (g62 g1398)
-                                               g1402)
-                                             g1396)
-                                           (g1400
-                                             ((top-level-value 'fx+)
-                                               g1402
-                                               '1))))]))])
-                            (void))
-                           '0)])
-                       ((top-level-value 'vector-length) g1397))]))])
-              (void)
-              (void)
-              (void))])
-         (case-lambda
-           [(g1403 g1404)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g107 g1403 g1404)])
-              (case-lambda
-                [(g1405 g1406)
-                 ((top-level-value 'values)
-                   (if (g49 g1405) (g53 g1405) g1405)
-                   g1406)]))])
-         (case-lambda
-           [(g1407 g1408)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g107 g1407 g1408)])
-              (case-lambda [(g1409 g1410) g1409]))])
-         (case-lambda
-           [(g1411 g1412)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g107 g1411 g1412)])
-              (case-lambda
-                [(g1413 g1414) (if (g49 g1413) (g53 g1413) g1413)]))])
-         (case-lambda
-           [(g1415 g1416)
-            (if ((top-level-value 'eq?)
-                  ((case-lambda
-                     [(g1417)
-                      ((case-lambda
-                         [(g1418)
-                          (if (g7 g1418)
-                              ((top-level-value 'annotation-expression)
-                                g1418)
-                              g1418)])
-                        (if (g2 g1417) (g3 g1417) g1417))])
-                    g1415)
-                  ((case-lambda
-                     [(g1419)
-                      ((case-lambda
-                         [(g1420)
-                          (if (g7 g1420)
-                              ((top-level-value 'annotation-expression)
-                                g1420)
-                              g1420)])
-                        (if (g2 g1419) (g3 g1419) g1419))])
-                    g1416))
-                ((top-level-value 'eq?)
-                  (g110 g1415 '(()))
-                  (g110 g1416 '(())))
-                '#f)])
-         (case-lambda
-           [(g1421 g1422)
-            (if ((top-level-value 'eq?)
-                  ((case-lambda
-                     [(g1423)
-                      ((case-lambda
-                         [(g1424)
-                          (if (g7 g1424)
-                              ((top-level-value 'annotation-expression)
-                                g1424)
-                              g1424)])
-                        (if (g2 g1423) (g3 g1423) g1423))])
-                    g1421)
-                  ((case-lambda
-                     [(g1425)
-                      ((case-lambda
-                         [(g1426)
-                          (if (g7 g1426)
-                              ((top-level-value 'annotation-expression)
-                                g1426)
-                              g1426)])
-                        (if (g2 g1425) (g3 g1425) g1425))])
-                    g1422))
-                ((case-lambda
-                   [(g1427 g1428)
-                    ((case-lambda
-                       [(g1429)
-                        (if g1429
-                            g1429
-                            (if ((case-lambda
-                                   [(g1430)
-                                    (if g1430
-                                        g1430
-                                        ((top-level-value 'symbol?)
-                                          g1427))])
-                                  ((top-level-value 'not) g1427))
-                                ((case-lambda
-                                   [(g1431)
-                                    (if g1431
-                                        g1431
-                                        ((top-level-value 'symbol?)
-                                          g1428))])
-                                  ((top-level-value 'not) g1428))
-                                '#f))])
-                      ((top-level-value 'eq?) g1427 g1428))])
-                  (g110 g1421 '(()))
-                  (g110 g1422 '(())))
-                '#f)])
-         (case-lambda
-           [(g1432 g1433 g1434 g1435)
-            (if ((top-level-value 'eq?) g1432 g1434)
-                (g101 g1433 g1435)
-                '#f)])
-         (case-lambda
-           [(g1436 g1437)
-            (g113
-              ((case-lambda
-                 [(g1438)
-                  ((case-lambda
-                     [(g1439)
-                      (if (g7 g1439)
-                          ((top-level-value 'annotation-expression) g1439)
-                          g1439)])
-                    (if (g2 g1438) (g3 g1438) g1438))])
-                g1436)
-              (g42 g1436)
-              ((case-lambda
-                 [(g1440)
-                  ((case-lambda
-                     [(g1441)
-                      (if (g7 g1441)
-                          ((top-level-value 'annotation-expression) g1441)
-                          g1441)])
-                    (if (g2 g1440) (g3 g1440) g1440))])
-                g1437)
-              (g42 g1437))])
-         (case-lambda
-           [(g1442)
-            (if (((case-lambda
-                    [(g1443)
-                     ((case-lambda
-                        [(g1444) (begin (set! g1443 g1444) g1443)])
-                       (case-lambda
-                         [(g1445)
-                          ((case-lambda
-                             [(g1446)
-                              (if g1446
-                                  g1446
-                                  (if (g41 ((top-level-value 'car) g1445))
-                                      (g1443
-                                        ((top-level-value 'cdr) g1445))
-                                      '#f))])
-                            ((top-level-value 'null?) g1445))]))])
-                   (void))
-                  g1442)
-                (g116 g1442)
-                '#f)])
-         (case-lambda
-           [(g1447)
-            (((case-lambda
-                [(g1448)
-                 ((case-lambda [(g1449) (begin (set! g1448 g1449) g1448)])
-                   (case-lambda
-                     [(g1450)
-                      ((case-lambda
-                         [(g1451)
-                          (if g1451
-                              g1451
-                              (if ((top-level-value 'not)
-                                    (g118
-                                      ((top-level-value 'car) g1450)
-                                      ((top-level-value 'cdr) g1450)))
-                                  (g1448 ((top-level-value 'cdr) g1450))
-                                  '#f))])
-                        ((top-level-value 'null?) g1450))]))])
-               (void))
-              g1447)])
-         (case-lambda
-           [(g1452 g1453 g1454)
-            (((case-lambda
-                [(g1455)
-                 ((case-lambda [(g1456) (begin (set! g1455 g1456) g1455)])
-                   (case-lambda
-                     [(g1457 g1458)
-                      (if ((top-level-value 'null?) g1457)
-                          ((top-level-value 'syntax-error) g1453)
-                          (if (g41 ((top-level-value 'car) g1457))
-                              (if (g118
-                                    ((top-level-value 'car) g1457)
-                                    g1458)
-                                  ((top-level-value 'syntax-error)
-                                    ((top-level-value 'car) g1457)
-                                    '"duplicate "
-                                    g1454)
-                                  (g1455
-                                    ((top-level-value 'cdr) g1457)
-                                    ((top-level-value 'cons)
-                                      ((top-level-value 'car) g1457)
-                                      g1458)))
-                              ((top-level-value 'syntax-error)
-                                ((top-level-value 'car) g1457)
-                                '"invalid "
-                                g1454)))]))])
-               (void))
-              g1452
-              '())])
-         (case-lambda
-           [(g1459 g1460)
-            (if ((top-level-value 'not)
-                  ((top-level-value 'null?) g1460))
-                ((case-lambda
-                   [(g1461)
-                    (if g1461
-                        g1461
-                        (g118 g1459 ((top-level-value 'cdr) g1460)))])
-                  (g114 g1459 ((top-level-value 'car) g1460)))
-                '#f)])
-         (case-lambda
-           [(g1462 g1463)
-            (if (if ((top-level-value 'null?) (g46 g1463))
-                    ((top-level-value 'null?) (g47 g1463))
-                    '#f)
-                g1462
-                (if (g2 g1462)
-                    (g1 (g3 g1462) (g98 g1463 (g4 g1462)))
-                    (if ((top-level-value 'null?) g1462)
-                        g1462
-                        (g1 g1462 g1463))))])
-         (case-lambda
-           [(g1464 g1465 g1466)
-            (g119
-              (if (g7 g1466)
-                  (begin
-                    (if ((top-level-value 'not)
-                          ((top-level-value 'eq?)
-                            ((top-level-value 'annotation-expression)
-                              g1466)
-                            g1464))
-                        ((top-level-value 'error)
-                          'sc-expand
-                          '"internal error in source-wrap: ae/x mismatch")
-                        (#%void))
-                    g1466)
-                  g1464)
-              g1465)])
-         (case-lambda
-           [(g1467 g1468)
-            ((top-level-value 'map)
-              (case-lambda
-                [(g1469)
-                 (if (g112
-                       g1469
-                       '#(syntax-object compile
-                          ((top) #(ribcage () () ())
-                            #(ribcage #(x) #((top)) #("i"))
-                            #(ribcage () () ())
-                            #(ribcage #(when-list w) #((top) (top))
-                              #("i" "i"))
-                            #(ribcage
-                              (lambda-var-list gen-var strip strip*
-                               strip-annotation ellipsis? chi-void
-                               chi-local-syntax chi-lambda-clause
-                               parse-begin parse-alias parse-eval-when
-                               parse-meta parse-define-syntax parse-define
-                               parse-import parse-module do-import!
-                               lookup-import-label import-mark-delta
-                               chi-internal chi-body chi-macro chi-set!
-                               chi-application chi-expr chi chi-sequence
-                               chi-meta-frob chi-frobs ct-eval/residualize3
-                               ct-eval/residualize2 rt-eval/residualize
-                               initial-mode-set update-mode-set
-                               do-top-import vfor-each vmap chi-external
-                               check-defined-ids check-module-exports
-                               id-set-diff chi-top-module set-frob-meta?!
-                               set-frob-e! frob-meta? frob-e frob?
-                               make-frob create-module-binding
-                               set-module-binding-exported!
-                               set-module-binding-val!
-                               set-module-binding-imps!
-                               set-module-binding-label!
-                               set-module-binding-id!
-                               set-module-binding-type!
-                               module-binding-exported module-binding-val
-                               module-binding-imps module-binding-label
-                               module-binding-id module-binding-type
-                               module-binding? make-module-binding
-                               make-resolved-interface
-                               make-unresolved-interface
-                               set-interface-token! set-interface-exports!
-                               set-interface-marks! interface-token
-                               interface-exports interface-marks interface?
-                               make-interface flatten-exports chi-top
-                               chi-top-sequence chi-top* syntax-type
-                               chi-when-list source-wrap wrap
-                               bound-id-member? invalid-ids-error
-                               distinct-bound-ids? valid-bound-ids?
-                               bound-id=? help-bound-id=? literal-id=?
-                               free-id=? id-var-name id-var-name-loc
-                               id-var-name&marks id-var-name-loc&marks
-                               top-id-free-var-name top-id-bound-var-name
-                               anon diff-marks same-marks? join-subst
-                               join-marks join-wraps smart-append
-                               resolved-id-var-name id->resolved-id
-                               make-resolved-id make-binding-wrap
-                               store-import-binding
-                               lookup-import-binding-name
-                               extend-ribcage-subst!
-                               extend-ribcage-barrier-help!
-                               extend-ribcage-barrier!
-                               import-extend-ribcage! extend-ribcage!
-                               make-empty-ribcage barrier-marker new-mark
-                               anti-mark the-anti-mark set-env-wrap!
-                               set-env-top-ribcage! env-wrap
-                               env-top-ribcage env? make-env
-                               set-import-interface-new-marks!
-                               set-import-interface-interface!
-                               import-interface-new-marks
-                               import-interface-interface import-interface?
-                               make-import-interface
-                               set-top-ribcage-mutable?!
-                               set-top-ribcage-key! top-ribcage-mutable?
-                               top-ribcage-key top-ribcage?
-                               make-top-ribcage set-ribcage-labels!
-                               set-ribcage-marks! set-ribcage-symnames!
-                               ribcage-labels ribcage-marks
-                               ribcage-symnames ribcage? make-ribcage
-                               gen-labels label? gen-label
-                               set-indirect-label! get-indirect-label
-                               indirect-label? gen-indirect-label anon
-                               only-top-marked? top-marked? top-wrap
-                               empty-wrap wrap-subst wrap-marks make-wrap
-                               id-sym-name&marks id-subst id-marks
-                               id-sym-name id? nonsymbol-id? global-extend
-                               defer-or-eval-transformer
-                               make-transformer-binding lookup lookup*
-                               displaced-lexical-error displaced-lexical?
-                               extend-var-env* extend-env* extend-env
-                               null-env binding? set-binding-value!
-                               set-binding-type! binding-value binding-type
-                               make-binding sanitize-binding arg-check
-                               no-source unannotate self-evaluating?
-                               lexical-var? build-lexical-var
-                               build-top-module build-body build-letrec
-                               build-sequence build-data build-primref
-                               built-lambda? build-lambda
-                               build-revisit-only build-visit-only
-                               build-cte-install build-global-definition
-                               build-global-assignment
-                               build-global-reference
-                               build-lexical-assignment
-                               build-lexical-reference build-conditional
-                               build-application generate-id
-                               put-import-binding get-import-binding
-                               read-only-binding?
-                               put-global-definition-hook
-                               get-global-definition-hook put-cte-hook
-                               gensym-hook error-hook
-                               define-top-level-value-hook local-eval-hook
-                               top-level-eval-hook annotation?
-                               set-syntax-object-wrap!
-                               set-syntax-object-expression!
-                               syntax-object-wrap syntax-object-expression
-                               syntax-object? make-syntax-object noexpand
-                               let-values define-structure unless when)
-                              ((top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) ("m" top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top)
-                               ("m" top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top) (top))
-                              ("i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                               "i"))
-                            #(top-ribcage *top* #t))))
-                     'compile
-                     (if (g112
-                           g1469
-                           '#(syntax-object load
-                              ((top) #(ribcage () () ())
-                                #(ribcage #(x) #((top)) #("i"))
-                                #(ribcage () () ())
-                                #(ribcage #(when-list w) #((top) (top))
-                                  #("i" "i"))
-                                #(ribcage
-                                  (lambda-var-list gen-var strip strip*
-                                   strip-annotation ellipsis? chi-void
-                                   chi-local-syntax chi-lambda-clause
-                                   parse-begin parse-alias parse-eval-when
-                                   parse-meta parse-define-syntax
-                                   parse-define parse-import parse-module
-                                   do-import! lookup-import-label
-                                   import-mark-delta chi-internal chi-body
-                                   chi-macro chi-set! chi-application
-                                   chi-expr chi chi-sequence chi-meta-frob
-                                   chi-frobs ct-eval/residualize3
-                                   ct-eval/residualize2 rt-eval/residualize
-                                   initial-mode-set update-mode-set
-                                   do-top-import vfor-each vmap
-                                   chi-external check-defined-ids
-                                   check-module-exports id-set-diff
-                                   chi-top-module set-frob-meta?!
-                                   set-frob-e! frob-meta? frob-e frob?
-                                   make-frob create-module-binding
-                                   set-module-binding-exported!
-                                   set-module-binding-val!
-                                   set-module-binding-imps!
-                                   set-module-binding-label!
-                                   set-module-binding-id!
-                                   set-module-binding-type!
-                                   module-binding-exported
-                                   module-binding-val module-binding-imps
-                                   module-binding-label module-binding-id
-                                   module-binding-type module-binding?
-                                   make-module-binding
-                                   make-resolved-interface
-                                   make-unresolved-interface
-                                   set-interface-token!
-                                   set-interface-exports!
-                                   set-interface-marks! interface-token
-                                   interface-exports interface-marks
-                                   interface? make-interface
-                                   flatten-exports chi-top chi-top-sequence
-                                   chi-top* syntax-type chi-when-list
-                                   source-wrap wrap bound-id-member?
-                                   invalid-ids-error distinct-bound-ids?
-                                   valid-bound-ids? bound-id=?
-                                   help-bound-id=? literal-id=? free-id=?
-                                   id-var-name id-var-name-loc
-                                   id-var-name&marks id-var-name-loc&marks
-                                   top-id-free-var-name
-                                   top-id-bound-var-name anon diff-marks
-                                   same-marks? join-subst join-marks
-                                   join-wraps smart-append
-                                   resolved-id-var-name id->resolved-id
-                                   make-resolved-id make-binding-wrap
-                                   store-import-binding
-                                   lookup-import-binding-name
-                                   extend-ribcage-subst!
-                                   extend-ribcage-barrier-help!
-                                   extend-ribcage-barrier!
-                                   import-extend-ribcage! extend-ribcage!
-                                   make-empty-ribcage barrier-marker
-                                   new-mark anti-mark the-anti-mark
-                                   set-env-wrap! set-env-top-ribcage!
-                                   env-wrap env-top-ribcage env? make-env
-                                   set-import-interface-new-marks!
-                                   set-import-interface-interface!
-                                   import-interface-new-marks
-                                   import-interface-interface
-                                   import-interface? make-import-interface
-                                   set-top-ribcage-mutable?!
-                                   set-top-ribcage-key!
-                                   top-ribcage-mutable? top-ribcage-key
-                                   top-ribcage? make-top-ribcage
-                                   set-ribcage-labels! set-ribcage-marks!
-                                   set-ribcage-symnames! ribcage-labels
-                                   ribcage-marks ribcage-symnames ribcage?
-                                   make-ribcage gen-labels label? gen-label
-                                   set-indirect-label! get-indirect-label
-                                   indirect-label? gen-indirect-label anon
-                                   only-top-marked? top-marked? top-wrap
-                                   empty-wrap wrap-subst wrap-marks
-                                   make-wrap id-sym-name&marks id-subst
-                                   id-marks id-sym-name id? nonsymbol-id?
-                                   global-extend defer-or-eval-transformer
-                                   make-transformer-binding lookup lookup*
-                                   displaced-lexical-error
-                                   displaced-lexical? extend-var-env*
-                                   extend-env* extend-env null-env binding?
-                                   set-binding-value! set-binding-type!
-                                   binding-value binding-type make-binding
-                                   sanitize-binding arg-check no-source
-                                   unannotate self-evaluating? lexical-var?
-                                   build-lexical-var build-top-module
-                                   build-body build-letrec build-sequence
-                                   build-data build-primref built-lambda?
-                                   build-lambda build-revisit-only
-                                   build-visit-only build-cte-install
-                                   build-global-definition
-                                   build-global-assignment
-                                   build-global-reference
-                                   build-lexical-assignment
-                                   build-lexical-reference
-                                   build-conditional build-application
-                                   generate-id put-import-binding
-                                   get-import-binding read-only-binding?
-                                   put-global-definition-hook
-                                   get-global-definition-hook put-cte-hook
-                                   gensym-hook error-hook
-                                   define-top-level-value-hook
-                                   local-eval-hook top-level-eval-hook
-                                   annotation? set-syntax-object-wrap!
-                                   set-syntax-object-expression!
-                                   syntax-object-wrap
-                                   syntax-object-expression syntax-object?
-                                   make-syntax-object noexpand let-values
-                                   define-structure unless when)
-                                  ((top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   ("m" top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) ("m" top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top) (top) (top)
-                                   (top) (top) (top) (top))
-                                  ("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                   "i" "i"))
-                                #(top-ribcage *top* #t))))
-                         'load
-                         (if (g112
-                               g1469
-                               '#(syntax-object visit
-                                  ((top) #(ribcage () () ())
-                                    #(ribcage #(x) #((top)) #("i"))
-                                    #(ribcage () () ())
-                                    #(ribcage #(when-list w) #((top) (top))
-                                      #("i" "i"))
-                                    #(ribcage
-                                      (lambda-var-list gen-var strip strip*
-                                       strip-annotation ellipsis? chi-void
-                                       chi-local-syntax chi-lambda-clause
-                                       parse-begin parse-alias
-                                       parse-eval-when parse-meta
-                                       parse-define-syntax parse-define
-                                       parse-import parse-module do-import!
-                                       lookup-import-label
-                                       import-mark-delta chi-internal
-                                       chi-body chi-macro chi-set!
-                                       chi-application chi-expr chi
-                                       chi-sequence chi-meta-frob chi-frobs
-                                       ct-eval/residualize3
-                                       ct-eval/residualize2
-                                       rt-eval/residualize initial-mode-set
-                                       update-mode-set do-top-import
-                                       vfor-each vmap chi-external
-                                       check-defined-ids
-                                       check-module-exports id-set-diff
-                                       chi-top-module set-frob-meta?!
-                                       set-frob-e! frob-meta? frob-e frob?
-                                       make-frob create-module-binding
-                                       set-module-binding-exported!
-                                       set-module-binding-val!
-                                       set-module-binding-imps!
-                                       set-module-binding-label!
-                                       set-module-binding-id!
-                                       set-module-binding-type!
-                                       module-binding-exported
-                                       module-binding-val
-                                       module-binding-imps
-                                       module-binding-label
-                                       module-binding-id
-                                       module-binding-type module-binding?
-                                       make-module-binding
-                                       make-resolved-interface
-                                       make-unresolved-interface
-                                       set-interface-token!
-                                       set-interface-exports!
-                                       set-interface-marks! interface-token
-                                       interface-exports interface-marks
-                                       interface? make-interface
-                                       flatten-exports chi-top
-                                       chi-top-sequence chi-top*
-                                       syntax-type chi-when-list
-                                       source-wrap wrap bound-id-member?
-                                       invalid-ids-error
-                                       distinct-bound-ids? valid-bound-ids?
-                                       bound-id=? help-bound-id=?
-                                       literal-id=? free-id=? id-var-name
-                                       id-var-name-loc id-var-name&marks
-                                       id-var-name-loc&marks
-                                       top-id-free-var-name
-                                       top-id-bound-var-name anon
-                                       diff-marks same-marks? join-subst
-                                       join-marks join-wraps smart-append
-                                       resolved-id-var-name id->resolved-id
-                                       make-resolved-id make-binding-wrap
-                                       store-import-binding
-                                       lookup-import-binding-name
-                                       extend-ribcage-subst!
-                                       extend-ribcage-barrier-help!
-                                       extend-ribcage-barrier!
-                                       import-extend-ribcage!
-                                       extend-ribcage! make-empty-ribcage
-                                       barrier-marker new-mark anti-mark
-                                       the-anti-mark set-env-wrap!
-                                       set-env-top-ribcage! env-wrap
-                                       env-top-ribcage env? make-env
-                                       set-import-interface-new-marks!
-                                       set-import-interface-interface!
-                                       import-interface-new-marks
-                                       import-interface-interface
-                                       import-interface?
-                                       make-import-interface
-                                       set-top-ribcage-mutable?!
-                                       set-top-ribcage-key!
-                                       top-ribcage-mutable? top-ribcage-key
-                                       top-ribcage? make-top-ribcage
-                                       set-ribcage-labels!
-                                       set-ribcage-marks!
-                                       set-ribcage-symnames! ribcage-labels
-                                       ribcage-marks ribcage-symnames
-                                       ribcage? make-ribcage gen-labels
-                                       label? gen-label set-indirect-label!
-                                       get-indirect-label indirect-label?
-                                       gen-indirect-label anon
-                                       only-top-marked? top-marked?
-                                       top-wrap empty-wrap wrap-subst
-                                       wrap-marks make-wrap
-                                       id-sym-name&marks id-subst id-marks
-                                       id-sym-name id? nonsymbol-id?
-                                       global-extend
-                                       defer-or-eval-transformer
-                                       make-transformer-binding lookup
-                                       lookup* displaced-lexical-error
-                                       displaced-lexical? extend-var-env*
-                                       extend-env* extend-env null-env
-                                       binding? set-binding-value!
-                                       set-binding-type! binding-value
-                                       binding-type make-binding
-                                       sanitize-binding arg-check no-source
-                                       unannotate self-evaluating?
-                                       lexical-var? build-lexical-var
-                                       build-top-module build-body
-                                       build-letrec build-sequence
-                                       build-data build-primref
-                                       built-lambda? build-lambda
-                                       build-revisit-only build-visit-only
-                                       build-cte-install
-                                       build-global-definition
-                                       build-global-assignment
-                                       build-global-reference
-                                       build-lexical-assignment
-                                       build-lexical-reference
-                                       build-conditional build-application
-                                       generate-id put-import-binding
-                                       get-import-binding
-                                       read-only-binding?
-                                       put-global-definition-hook
-                                       get-global-definition-hook
-                                       put-cte-hook gensym-hook error-hook
-                                       define-top-level-value-hook
-                                       local-eval-hook top-level-eval-hook
-                                       annotation? set-syntax-object-wrap!
-                                       set-syntax-object-expression!
-                                       syntax-object-wrap
-                                       syntax-object-expression
-                                       syntax-object? make-syntax-object
-                                       noexpand let-values define-structure
-                                       unless when)
-                                      ((top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       ("m" top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) ("m" top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top)
-                                       (top) (top) (top) (top) (top) (top))
-                                      ("i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                       "i" "i" "i" "i" "i" "i" "i"))
-                                    #(top-ribcage *top* #t))))
-                             'visit
-                             (if (g112
-                                   g1469
-                                   '#(syntax-object revisit
-                                      ((top) #(ribcage () () ())
-                                        #(ribcage #(x) #((top)) #("i"))
-                                        #(ribcage () () ())
-                                        #(ribcage #(when-list w)
-                                          #((top) (top)) #("i" "i"))
-                                        #(ribcage
-                                          (lambda-var-list gen-var strip
-                                           strip* strip-annotation
-                                           ellipsis? chi-void
-                                           chi-local-syntax
-                                           chi-lambda-clause parse-begin
-                                           parse-alias parse-eval-when
-                                           parse-meta parse-define-syntax
-                                           parse-define parse-import
-                                           parse-module do-import!
-                                           lookup-import-label
-                                           import-mark-delta chi-internal
-                                           chi-body chi-macro chi-set!
-                                           chi-application chi-expr chi
-                                           chi-sequence chi-meta-frob
-                                           chi-frobs ct-eval/residualize3
-                                           ct-eval/residualize2
-                                           rt-eval/residualize
-                                           initial-mode-set update-mode-set
-                                           do-top-import vfor-each vmap
-                                           chi-external check-defined-ids
-                                           check-module-exports id-set-diff
-                                           chi-top-module set-frob-meta?!
-                                           set-frob-e! frob-meta? frob-e
-                                           frob? make-frob
-                                           create-module-binding
-                                           set-module-binding-exported!
-                                           set-module-binding-val!
-                                           set-module-binding-imps!
-                                           set-module-binding-label!
-                                           set-module-binding-id!
-                                           set-module-binding-type!
-                                           module-binding-exported
-                                           module-binding-val
-                                           module-binding-imps
-                                           module-binding-label
-                                           module-binding-id
-                                           module-binding-type
-                                           module-binding?
-                                           make-module-binding
-                                           make-resolved-interface
-                                           make-unresolved-interface
-                                           set-interface-token!
-                                           set-interface-exports!
-                                           set-interface-marks!
-                                           interface-token
-                                           interface-exports
-                                           interface-marks interface?
-                                           make-interface flatten-exports
-                                           chi-top chi-top-sequence
-                                           chi-top* syntax-type
-                                           chi-when-list source-wrap wrap
-                                           bound-id-member?
-                                           invalid-ids-error
-                                           distinct-bound-ids?
-                                           valid-bound-ids? bound-id=?
-                                           help-bound-id=? literal-id=?
-                                           free-id=? id-var-name
-                                           id-var-name-loc
-                                           id-var-name&marks
-                                           id-var-name-loc&marks
-                                           top-id-free-var-name
-                                           top-id-bound-var-name anon
-                                           diff-marks same-marks?
-                                           join-subst join-marks join-wraps
-                                           smart-append
-                                           resolved-id-var-name
-                                           id->resolved-id make-resolved-id
-                                           make-binding-wrap
-                                           store-import-binding
-                                           lookup-import-binding-name
-                                           extend-ribcage-subst!
-                                           extend-ribcage-barrier-help!
-                                           extend-ribcage-barrier!
-                                           import-extend-ribcage!
-                                           extend-ribcage!
-                                           make-empty-ribcage
-                                           barrier-marker new-mark
-                                           anti-mark the-anti-mark
-                                           set-env-wrap!
-                                           set-env-top-ribcage! env-wrap
-                                           env-top-ribcage env? make-env
-                                           set-import-interface-new-marks!
-                                           set-import-interface-interface!
-                                           import-interface-new-marks
-                                           import-interface-interface
-                                           import-interface?
-                                           make-import-interface
-                                           set-top-ribcage-mutable?!
-                                           set-top-ribcage-key!
-                                           top-ribcage-mutable?
-                                           top-ribcage-key top-ribcage?
-                                           make-top-ribcage
-                                           set-ribcage-labels!
-                                           set-ribcage-marks!
-                                           set-ribcage-symnames!
-                                           ribcage-labels ribcage-marks
-                                           ribcage-symnames ribcage?
-                                           make-ribcage gen-labels label?
-                                           gen-label set-indirect-label!
-                                           get-indirect-label
-                                           indirect-label?
-                                           gen-indirect-label anon
-                                           only-top-marked? top-marked?
-                                           top-wrap empty-wrap wrap-subst
-                                           wrap-marks make-wrap
-                                           id-sym-name&marks id-subst
-                                           id-marks id-sym-name id?
-                                           nonsymbol-id? global-extend
-                                           defer-or-eval-transformer
-                                           make-transformer-binding lookup
-                                           lookup* displaced-lexical-error
-                                           displaced-lexical?
-                                           extend-var-env* extend-env*
-                                           extend-env null-env binding?
-                                           set-binding-value!
-                                           set-binding-type! binding-value
-                                           binding-type make-binding
-                                           sanitize-binding arg-check
-                                           no-source unannotate
-                                           self-evaluating? lexical-var?
-                                           build-lexical-var
-                                           build-top-module build-body
-                                           build-letrec build-sequence
-                                           build-data build-primref
-                                           built-lambda? build-lambda
-                                           build-revisit-only
-                                           build-visit-only
-                                           build-cte-install
-                                           build-global-definition
-                                           build-global-assignment
-                                           build-global-reference
-                                           build-lexical-assignment
-                                           build-lexical-reference
-                                           build-conditional
-                                           build-application generate-id
-                                           put-import-binding
-                                           get-import-binding
-                                           read-only-binding?
-                                           put-global-definition-hook
-                                           get-global-definition-hook
-                                           put-cte-hook gensym-hook
-                                           error-hook
-                                           define-top-level-value-hook
-                                           local-eval-hook
-                                           top-level-eval-hook annotation?
-                                           set-syntax-object-wrap!
-                                           set-syntax-object-expression!
-                                           syntax-object-wrap
-                                           syntax-object-expression
-                                           syntax-object?
-                                           make-syntax-object noexpand
-                                           let-values define-structure
-                                           unless when)
-                                          ((top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) ("m" top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) ("m" top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top))
-                                          ("i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i" "i" "i" "i" "i" "i"
-                                           "i"))
-                                        #(top-ribcage *top* #t))))
-                                 'revisit
-                                 (if (g112
-                                       g1469
-                                       '#(syntax-object eval
-                                          ((top) #(ribcage () () ())
-                                            #(ribcage #(x) #((top)) #("i"))
-                                            #(ribcage () () ())
-                                            #(ribcage #(when-list w)
-                                              #((top) (top)) #("i" "i"))
-                                            #(ribcage
-                                              (lambda-var-list gen-var
-                                               strip strip*
-                                               strip-annotation ellipsis?
-                                               chi-void chi-local-syntax
-                                               chi-lambda-clause
-                                               parse-begin parse-alias
-                                               parse-eval-when parse-meta
-                                               parse-define-syntax
-                                               parse-define parse-import
-                                               parse-module do-import!
-                                               lookup-import-label
-                                               import-mark-delta
-                                               chi-internal chi-body
-                                               chi-macro chi-set!
-                                               chi-application chi-expr chi
-                                               chi-sequence chi-meta-frob
-                                               chi-frobs
-                                               ct-eval/residualize3
-                                               ct-eval/residualize2
-                                               rt-eval/residualize
-                                               initial-mode-set
-                                               update-mode-set
-                                               do-top-import vfor-each vmap
-                                               chi-external
-                                               check-defined-ids
-                                               check-module-exports
-                                               id-set-diff chi-top-module
-                                               set-frob-meta?! set-frob-e!
-                                               frob-meta? frob-e frob?
-                                               make-frob
-                                               create-module-binding
-                                               set-module-binding-exported!
-                                               set-module-binding-val!
-                                               set-module-binding-imps!
-                                               set-module-binding-label!
-                                               set-module-binding-id!
-                                               set-module-binding-type!
-                                               module-binding-exported
-                                               module-binding-val
-                                               module-binding-imps
-                                               module-binding-label
-                                               module-binding-id
-                                               module-binding-type
-                                               module-binding?
-                                               make-module-binding
-                                               make-resolved-interface
-                                               make-unresolved-interface
-                                               set-interface-token!
-                                               set-interface-exports!
-                                               set-interface-marks!
-                                               interface-token
-                                               interface-exports
-                                               interface-marks interface?
-                                               make-interface
-                                               flatten-exports chi-top
-                                               chi-top-sequence chi-top*
-                                               syntax-type chi-when-list
-                                               source-wrap wrap
-                                               bound-id-member?
-                                               invalid-ids-error
-                                               distinct-bound-ids?
-                                               valid-bound-ids? bound-id=?
-                                               help-bound-id=? literal-id=?
-                                               free-id=? id-var-name
-                                               id-var-name-loc
-                                               id-var-name&marks
-                                               id-var-name-loc&marks
-                                               top-id-free-var-name
-                                               top-id-bound-var-name anon
-                                               diff-marks same-marks?
-                                               join-subst join-marks
-                                               join-wraps smart-append
-                                               resolved-id-var-name
-                                               id->resolved-id
-                                               make-resolved-id
-                                               make-binding-wrap
-                                               store-import-binding
-                                               lookup-import-binding-name
-                                               extend-ribcage-subst!
-                                               extend-ribcage-barrier-help!
-                                               extend-ribcage-barrier!
-                                               import-extend-ribcage!
-                                               extend-ribcage!
-                                               make-empty-ribcage
-                                               barrier-marker new-mark
-                                               anti-mark the-anti-mark
-                                               set-env-wrap!
-                                               set-env-top-ribcage!
-                                               env-wrap env-top-ribcage
-                                               env? make-env
-                                               set-import-interface-new-marks!
-                                               set-import-interface-interface!
-                                               import-interface-new-marks
-                                               import-interface-interface
-                                               import-interface?
-                                               make-import-interface
-                                               set-top-ribcage-mutable?!
-                                               set-top-ribcage-key!
-                                               top-ribcage-mutable?
-                                               top-ribcage-key top-ribcage?
-                                               make-top-ribcage
-                                               set-ribcage-labels!
-                                               set-ribcage-marks!
-                                               set-ribcage-symnames!
-                                               ribcage-labels ribcage-marks
-                                               ribcage-symnames ribcage?
-                                               make-ribcage gen-labels
-                                               label? gen-label
-                                               set-indirect-label!
-                                               get-indirect-label
-                                               indirect-label?
-                                               gen-indirect-label anon
-                                               only-top-marked? top-marked?
-                                               top-wrap empty-wrap
-                                               wrap-subst wrap-marks
-                                               make-wrap id-sym-name&marks
-                                               id-subst id-marks
-                                               id-sym-name id?
-                                               nonsymbol-id? global-extend
-                                               defer-or-eval-transformer
-                                               make-transformer-binding
-                                               lookup lookup*
-                                               displaced-lexical-error
-                                               displaced-lexical?
-                                               extend-var-env* extend-env*
-                                               extend-env null-env binding?
-                                               set-binding-value!
-                                               set-binding-type!
-                                               binding-value binding-type
-                                               make-binding
-                                               sanitize-binding arg-check
-                                               no-source unannotate
-                                               self-evaluating?
-                                               lexical-var?
-                                               build-lexical-var
-                                               build-top-module build-body
-                                               build-letrec build-sequence
-                                               build-data build-primref
-                                               built-lambda? build-lambda
-                                               build-revisit-only
-                                               build-visit-only
-                                               build-cte-install
-                                               build-global-definition
-                                               build-global-assignment
-                                               build-global-reference
-                                               build-lexical-assignment
-                                               build-lexical-reference
-                                               build-conditional
-                                               build-application
-                                               generate-id
-                                               put-import-binding
-                                               get-import-binding
-                                               read-only-binding?
-                                               put-global-definition-hook
-                                               get-global-definition-hook
-                                               put-cte-hook gensym-hook
-                                               error-hook
-                                               define-top-level-value-hook
-                                               local-eval-hook
-                                               top-level-eval-hook
-                                               annotation?
-                                               set-syntax-object-wrap!
-                                               set-syntax-object-expression!
-                                               syntax-object-wrap
-                                               syntax-object-expression
-                                               syntax-object?
-                                               make-syntax-object noexpand
-                                               let-values define-structure
-                                               unless when)
-                                              ((top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               ("m" top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               ("m" top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top) (top) (top))
-                                              ("i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i" "i" "i" "i" "i"
-                                               "i"))
-                                            #(top-ribcage *top* #t))))
-                                     'eval
-                                     ((top-level-value 'syntax-error)
-                                       (g119 g1469 g1468)
-                                       '"invalid eval-when situation"))))))])
-              g1467)])
-         (case-lambda
-           [(g1470 g1471 g1472 g1473 g1474)
-            (if ((top-level-value 'symbol?) g1470)
-                ((case-lambda
-                   [(g1475)
-                    ((case-lambda
-                       [(g1476)
-                        ((case-lambda
-                           [(g1477)
-                            ((case-lambda
-                               [()
-                                ((case-lambda
-                                   [(g1478)
-                                    (if ((top-level-value 'memv)
-                                          g1478
-                                          '(macro macro!))
-                                        (g122
-                                          (g178 (g26 g1476) g1470 g1471
-                                            g1472 g1473 g1474)
-                                          g1471 '(()) '#f g1474)
-                                        ((top-level-value 'values) g1477
-                                          (g26 g1476) g1470 g1472 g1473))])
-                                  g1477)]))])
-                          (g25 g1476))])
-                      (g36 g1475 g1471))])
-                  (g110 g1470 g1472))
-                (if ((top-level-value 'pair?) g1470)
-                    ((case-lambda
-                       [(g1479)
-                        (if (g41 g1479)
-                            ((case-lambda
-                               [(g1480)
-                                ((case-lambda
-                                   [(g1481)
-                                    ((case-lambda
-                                       [(g1482)
-                                        ((case-lambda
-                                           [()
-                                            ((case-lambda
-                                               [(g1483)
-                                                (if ((top-level-value
-                                                       'memv)
-                                                      g1483
-                                                      '(lexical))
-                                                    ((top-level-value
-                                                       'values)
-                                                      'lexical-call
-                                                      (g26 g1481) g1470
-                                                      g1472 g1473)
-                                                    (if ((top-level-value
-                                                           'memv)
-                                                          g1483
-                                                          '(macro macro!))
-                                                        (g122
-                                                          (g178 (g26 g1481)
-                                                            g1470 g1471
-                                                            g1472 g1473
-                                                            g1474)
-                                                          g1471 '(()) '#f
-                                                          g1474)
-                                                        (if ((top-level-value
-                                                               'memv)
-                                                              g1483
-                                                              '(core))
-                                                            ((top-level-value
-                                                               'values)
-                                                              g1482
-                                                              (g26 g1481)
-                                                              g1470 g1472
-                                                              g1473)
-                                                            (if ((top-level-value
-                                                                   'memv)
-                                                                  g1483
-                                                                  '(begin))
-                                                                ((top-level-value
-                                                                   'values)
-                                                                  'begin-form
-                                                                  '#f g1470
-                                                                  g1472
-                                                                  g1473)
-                                                                (if ((top-level-value
-                                                                       'memv)
-                                                                      g1483
-                                                                      '(alias))
-                                                                    ((top-level-value
-                                                                       'values)
-                                                                      'alias-form
-                                                                      '#f
-                                                                      g1470
-                                                                      g1472
-                                                                      g1473)
-                                                                    (if ((top-level-value
-                                                                           'memv)
-                                                                          g1483
-                                                                          '(define))
-                                                                        ((top-level-value
-                                                                           'values)
-                                                                          'define-form
-                                                                          '#f
-                                                                          g1470
-                                                                          g1472
-                                                                          g1473)
-                                                                        (if ((top-level-value
-                                                                               'memv)
-                                                                              g1483
-                                                                              '(define-syntax))
-                                                                            ((top-level-value
-                                                                               'values)
-                                                                              'define-syntax-form
-                                                                              '#f
-                                                                              g1470
-                                                                              g1472
-                                                                              g1473)
-                                                                            (if ((top-level-value
-                                                                                   'memv)
-                                                                                  g1483
-                                                                                  '(set!))
-                                                                                (g177
-                                                                                  g1470
-                                                                                  g1471
-                                                                                  g1472
-                                                                                  g1473
-                                                                                  g1474)
-                                                                                (if ((top-level-value
-                                                                                       'memv)
-                                                                                      g1483
-                                                                                      '($module-key))
-                                                                                    ((top-level-value
-                                                                                       'values)
-                                                                                      '$module-form
-                                                                                      '#f
-                                                                                      g1470
-                                                                                      g1472
-                                                                                      g1473)
-                                                                                    (if ((top-level-value
-                                                                                           'memv)
-                                                                                          g1483
-                                                                                          '($import))
-                                                                                        ((top-level-value
-                                                                                           'values)
-                                                                                          '$import-form
-                                                                                          '#f
-                                                                                          g1470
-                                                                                          g1472
-                                                                                          g1473)
-                                                                                        (if ((top-level-value
-                                                                                               'memv)
-                                                                                              g1483
-                                                                                              '(eval-when))
-                                                                                            ((top-level-value
-                                                                                               'values)
-                                                                                              'eval-when-form
-                                                                                              '#f
-                                                                                              g1470
-                                                                                              g1472
-                                                                                              g1473)
-                                                                                            (if ((top-level-value
-                                                                                                   'memv)
-                                                                                                  g1483
-                                                                                                  '(meta))
-                                                                                                ((top-level-value
-                                                                                                   'values)
-                                                                                                  'meta-form
-                                                                                                  '#f
-                                                                                                  g1470
-                                                                                                  g1472
-                                                                                                  g1473)
-                                                                                                (if ((top-level-value
-                                                                                                       'memv)
-                                                                                                      g1483
-                                                                                                      '(local-syntax))
-                                                                                                    ((top-level-value
-                                                                                                       'values)
-                                                                                                      'local-syntax-form
-                                                                                                      (g26 g1481)
-                                                                                                      g1470
-                                                                                                      g1472
-                                                                                                      g1473)
-                                                                                                    ((top-level-value
-                                                                                                       'values)
-                                                                                                      'call
-                                                                                                      '#f
-                                                                                                      g1470
-                                                                                                      g1472
-                                                                                                      g1473))))))))))))))])
-                                              g1482)]))])
-                                      (g25 g1481))])
-                                  (g36 g1480 g1471))])
-                              (g110 g1479 g1472))
-                            ((top-level-value 'values) 'call '#f g1470
-                              g1472 g1473))])
-                      ((top-level-value 'car) g1470))
-                    (if (g2 g1470)
-                        (g122 (g3 g1470) g1471 (g98 g1472 (g4 g1470)) '#f
-                          g1474)
-                        (if (g7 g1470)
-                            (g122
-                              ((top-level-value 'annotation-expression)
-                                g1470)
-                              g1471 g1472 g1470 g1474)
-                            (if ((case-lambda
-                                   [(g1484)
-                                    ((case-lambda
-                                       [(g1485)
-                                        (if g1485
-                                            g1485
-                                            ((case-lambda
-                                               [(g1486)
-                                                (if g1486
-                                                    g1486
-                                                    ((case-lambda
-                                                       [(g1487)
-                                                        (if g1487
-                                                            g1487
-                                                            ((case-lambda
-                                                               [(g1488)
-                                                                (if g1488
-                                                                    g1488
-                                                                    ((top-level-value
-                                                                       'null?)
-                                                                      g1484))])
-                                                              ((top-level-value
-                                                                 'char?)
-                                                                g1484)))])
-                                                      ((top-level-value
-                                                         'string?)
-                                                        g1484)))])
-                                              ((top-level-value 'fixnum?)
-                                                g1484)))])
-                                      ((top-level-value 'boolean?)
-                                        g1484))])
-                                  g1470)
-                                ((top-level-value 'values) 'constant '#f
-                                  g1470 g1472 g1473)
-                                ((top-level-value 'values) 'other '#f g1470
-                                  g1472 g1473))))))])
-         (case-lambda
-           [(g1489 g1490 g1491 g1492 g1493 g1494 g1495)
-            ((case-lambda
-               [(g1496)
-                ((case-lambda
-                   [(g1497)
-                    ((case-lambda
-                       [(g1498)
-                        (begin
-                          (set! g1497 g1498)
-                          ((case-lambda
-                             [(g1499)
-                              (g20 '#f
-                                   ((top-level-value 'reverse)
-                                     ((top-level-value 'cons)
-                                       g1499
-                                       g1496)))])
-                            (g125 g1489 g1490 g1491 g1492 g1493 g1494 g1495
-                              g1497 '#f)))])
-                      (case-lambda
-                        [(g1500)
-                         (set! g1496
-                           ((top-level-value 'cons) g1500 g1496))]))])
-                  (void))])
-              '())])
-         (case-lambda
-           [(g1501 g1502 g1503 g1504 g1505 g1506 g1507 g1508 g1509)
-            (g20 g1504
-                 (((case-lambda
-                     [(g1510)
-                      ((case-lambda
-                         [(g1511) (begin (set! g1510 g1511) g1510)])
-                        (case-lambda
-                          [(g1512)
-                           (if ((top-level-value 'null?) g1512)
-                               '()
-                               ((case-lambda
-                                  [(g1513)
-                                   ((top-level-value 'cons)
-                                     g1513
-                                     (g1510
-                                       ((top-level-value 'cdr) g1512)))])
-                                 (g125 ((top-level-value 'car) g1512) g1502
-                                   g1503 g1505 g1506 g1507 g1508 g1509
-                                   '#f)))]))])
-                    (void))
-                   g1501))])
-         (case-lambda
-           [(g1514 g1515 g1516 g1517 g1518 g1519 g1520 g1521 g1522)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g122 g1514 g1515 g1516 '#f g1520)])
-              (case-lambda
-                [(g1523 g1524 g1525 g1526 g1527)
-                 ((case-lambda
-                    [(g1528)
-                     (if ((top-level-value 'memv) g1528 '(begin-form))
-                         ((case-lambda
-                            [(g1529)
-                             (if ((top-level-value 'null?) g1529)
-                                 (g194)
-                                 (g124 g1529 g1515 g1526 g1527 g1517 g1518
-                                   g1519 g1520 g1521))])
-                           (g191 g1525 g1526 g1527 '#t))
-                         (if ((top-level-value 'memv)
-                               g1528
-                               '(local-syntax-form))
-                             ((top-level-value 'call-with-values)
-                               (case-lambda
-                                 [()
-                                  (g193 g1524 g1525 g1515 g1515 g1526
-                                    g1527)])
-                               (case-lambda
-                                 [(g1530 g1531 g1532 g1533 g1534)
-                                  (g124 g1530 g1531 g1533 g1534 g1517 g1518
-                                    g1519 g1520 g1521)]))
-                             (if ((top-level-value 'memv)
-                                   g1528
-                                   '(eval-when-form))
-                                 ((top-level-value 'call-with-values)
-                                   (case-lambda
-                                     [() (g189 g1525 g1526 g1527)])
-                                   (case-lambda
-                                     [(g1535 g1536)
-                                      ((case-lambda
-                                         [(g1537 g1538)
-                                          (if (if ((top-level-value 'null?)
-                                                    g1537)
-                                                  ((top-level-value 'null?)
-                                                    g1538)
-                                                  '#f)
-                                              (g194)
-                                              (g124 g1536 g1515 g1526 g1527
-                                                g1537 g1538 g1519 g1520
-                                                g1521))])
-                                        (g166 g1535 g1517)
-                                        (g166 g1535 g1518))]))
-                                 (if ((top-level-value 'memv)
-                                       g1528
-                                       '(meta-form))
-                                     (g125 (g188 g1525 g1526 g1527) g1515
-                                       g1526 g1517 g1518 '#t g1520 g1521
-                                       '#t)
-                                     (if ((top-level-value 'memv)
-                                           g1528
-                                           '(define-syntax-form))
-                                         ((top-level-value
-                                            'call-with-values)
-                                           (case-lambda
-                                             [() (g187 g1525 g1526 g1527)])
-                                           (case-lambda
-                                             [(g1539 g1540 g1541)
-                                              ((case-lambda
-                                                 [(g1542)
-                                                  (begin
-                                                    (if (g33 g1542 g1515)
-                                                        (g34 g1542)
-                                                        (#%void))
-                                                    (if ((top-level-value
-                                                           'not)
-                                                          (g69 g1520))
-                                                        ((top-level-value
-                                                           'syntax-error)
-                                                          (g120
-                                                            g1525
-                                                            g1541
-                                                            g1527)
-                                                          '"invalid definition in read-only environment")
-                                                        (#%void))
-                                                    ((case-lambda
-                                                       [(g1543)
-                                                        ((top-level-value
-                                                           'call-with-values)
-                                                          (case-lambda
-                                                            [()
-                                                             (g105
-                                                               g1543
-                                                               (g46 (g4 g1542))
-                                                               g1520)])
-                                                          (case-lambda
-                                                            [(g1544 g1545)
-                                                             (begin
-                                                               (if ((top-level-value
-                                                                      'not)
-                                                                     ((top-level-value
-                                                                        'eq?)
-                                                                       (g110
-                                                                         g1542
-                                                                         '(()))
-                                                                       g1544))
-                                                                   ((top-level-value
-                                                                      'syntax-error)
-                                                                     (g120
-                                                                       g1525
-                                                                       g1541
-                                                                       g1527)
-                                                                     '"definition not permitted")
-                                                                   (#%void))
-                                                               (if (g15 g1544)
-                                                                   ((top-level-value
-                                                                      'syntax-error)
-                                                                     (g120
-                                                                       g1525
-                                                                       g1541
-                                                                       g1527)
-                                                                     '"invalid definition of read-only identifier")
-                                                                   (#%void))
-                                                               (g169
-                                                                 g1517
-                                                                 (case-lambda
-                                                                   [()
-                                                                    ((top-level-value
-                                                                       'list)
-                                                                      '#%$sc-put-cte
-                                                                      ((top-level-value
-                                                                         'list)
-                                                                        'quote
-                                                                        g1545)
-                                                                      (g174
-                                                                        g1540
-                                                                        g1515
-                                                                        g1515
-                                                                        g1541
-                                                                        '#t)
-                                                                      ((top-level-value
-                                                                         'list)
-                                                                        'quote
-                                                                        (g68 g1520)))])))]))])
-                                                      ((case-lambda
-                                                         [(g1546)
-                                                          ((case-lambda
-                                                             [(g1547)
-                                                              (if (g7 g1547)
-                                                                  ((top-level-value
-                                                                     'annotation-expression)
-                                                                    g1547)
-                                                                  g1547)])
-                                                            (if (g2 g1546)
-                                                                (g3 g1546)
-                                                                g1546))])
-                                                        g1542)))])
-                                                (g119 g1539 g1541))]))
-                                         (if ((top-level-value 'memv)
-                                               g1528
-                                               '(define-form))
-                                             ((top-level-value
-                                                'call-with-values)
-                                               (case-lambda
-                                                 [()
-                                                  (g186
-                                                    g1525
-                                                    g1526
-                                                    g1527)])
-                                               (case-lambda
-                                                 [(g1548 g1549 g1550)
-                                                  ((case-lambda
-                                                     [(g1551)
-                                                      (begin
-                                                        (if (g33 g1551
-                                                                 g1515)
-                                                            (g34 g1551)
-                                                            (#%void))
-                                                        (if ((top-level-value
-                                                               'not)
-                                                              (g69 g1520))
-                                                            ((top-level-value
-                                                               'syntax-error)
-                                                              (g120
-                                                                g1525
-                                                                g1550
-                                                                g1527)
-                                                              '"invalid definition in read-only environment")
-                                                            (#%void))
-                                                        ((case-lambda
-                                                           [(g1552)
-                                                            ((top-level-value
-                                                               'call-with-values)
-                                                              (case-lambda
-                                                                [()
-                                                                 (g105
-                                                                   g1552
-                                                                   (g46 (g4 g1551))
-                                                                   g1520)])
-                                                              (case-lambda
-                                                                [(g1553
-                                                                  g1554)
-                                                                 (begin
-                                                                   (if ((top-level-value
-                                                                          'not)
-                                                                         ((top-level-value
-                                                                            'eq?)
-                                                                           (g110
-                                                                             g1551
-                                                                             '(()))
-                                                                           g1553))
-                                                                       ((top-level-value
-                                                                          'syntax-error)
-                                                                         (g120
-                                                                           g1525
-                                                                           g1550
-                                                                           g1527)
-                                                                         '"definition not permitted")
-                                                                       (#%void))
-                                                                   (if (g15 g1553)
-                                                                       ((top-level-value
-                                                                          'syntax-error)
-                                                                         (g120
-                                                                           g1525
-                                                                           g1550
-                                                                           g1527)
-                                                                         '"invalid definition of read-only identifier")
-                                                                       (#%void))
-                                                                   (if g1519
-                                                                       (g169
-                                                                         g1517
-                                                                         (case-lambda
-                                                                           [()
-                                                                            (g20 '#f
-                                                                                 ((top-level-value
-                                                                                    'list)
-                                                                                   ((top-level-value
-                                                                                      'list)
-                                                                                     '#%$sc-put-cte
-                                                                                     ((top-level-value
-                                                                                        'list)
-                                                                                       'quote
-                                                                                       g1554)
-                                                                                     ((top-level-value
-                                                                                        'list)
-                                                                                       'quote
-                                                                                       ((top-level-value
-                                                                                          'cons)
-                                                                                         'meta-variable
-                                                                                         g1553))
-                                                                                     ((top-level-value
-                                                                                        'list)
-                                                                                       'quote
-                                                                                       (g68 g1520)))
-                                                                                   ((top-level-value
-                                                                                      'list)
-                                                                                     'set-top-level-value!
-                                                                                     ((top-level-value
-                                                                                        'list)
-                                                                                       'quote
-                                                                                       g1553)
-                                                                                     (g174
-                                                                                       g1549
-                                                                                       g1515
-                                                                                       g1515
-                                                                                       g1550
-                                                                                       '#t))))]))
-                                                                       ((case-lambda
-                                                                          [(g1555)
-                                                                           (g20 '#f
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  g1555
-                                                                                  (g168
-                                                                                    g1518
-                                                                                    (case-lambda
-                                                                                      [()
-                                                                                       ((top-level-value
-                                                                                          'list)
-                                                                                         'set-top-level-value!
-                                                                                         ((top-level-value
-                                                                                            'list)
-                                                                                           'quote
-                                                                                           g1553)
-                                                                                         (g174
-                                                                                           g1549
-                                                                                           g1515
-                                                                                           g1515
-                                                                                           g1550
-                                                                                           '#f))]))))])
-                                                                         (g169
-                                                                           g1517
-                                                                           (case-lambda
-                                                                             [()
-                                                                              ((top-level-value
-                                                                                 'list)
-                                                                                '#%$sc-put-cte
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  'quote
-                                                                                  g1554)
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  'quote
-                                                                                  ((top-level-value
-                                                                                     'cons)
-                                                                                    'global
-                                                                                    g1553))
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  'quote
-                                                                                  (g68 g1520)))])))))]))])
-                                                          ((case-lambda
-                                                             [(g1556)
-                                                              ((case-lambda
-                                                                 [(g1557)
-                                                                  (if (g7 g1557)
-                                                                      ((top-level-value
-                                                                         'annotation-expression)
-                                                                        g1557)
-                                                                      g1557)])
-                                                                (if (g2 g1556)
-                                                                    (g3 g1556)
-                                                                    g1556))])
-                                                            g1551)))])
-                                                    (g119 g1548 g1550))]))
-                                             (if ((top-level-value 'memv)
-                                                   g1528
-                                                   '($module-form))
-                                                 ((case-lambda
-                                                    [(g1558)
-                                                     ((top-level-value
-                                                        'call-with-values)
-                                                       (case-lambda
-                                                         [()
-                                                          (g184
-                                                            g1525
-                                                            g1526
-                                                            g1527
-                                                            (g45 (g46 g1526)
-                                                                 ((top-level-value
-                                                                    'cons)
-                                                                   g1558
-                                                                   (g47 g1526))))])
-                                                       (case-lambda
-                                                         [(g1559 g1560
-                                                           g1561 g1562)
-                                                          (begin
-                                                            (if (g33 g1560
-                                                                     g1515)
-                                                                (g34 (g119
-                                                                       g1560
-                                                                       g1526))
-                                                                (#%void))
-                                                            (if ((top-level-value
-                                                                   'not)
-                                                                  (g69 g1520))
-                                                                ((top-level-value
-                                                                   'syntax-error)
-                                                                  g1559
-                                                                  '"invalid definition in read-only environment")
-                                                                (#%void))
-                                                            (g158 g1559
-                                                              g1515 g1515
-                                                              g1520 g1558
-                                                              g1517 g1518
-                                                              g1519 g1560
-                                                              g1561 g1562
-                                                              g1521))]))])
-                                                   (g58 '() '() '()))
-                                                 (if ((top-level-value
-                                                        'memv)
-                                                       g1528
-                                                       '($import-form))
-                                                     ((top-level-value
-                                                        'call-with-values)
-                                                       (case-lambda
-                                                         [()
-                                                          (g185
-                                                            g1525
-                                                            g1526
-                                                            g1527)])
-                                                       (case-lambda
-                                                         [(g1563 g1564
-                                                           g1565)
-                                                          (begin
-                                                            (if ((top-level-value
-                                                                   'not)
-                                                                  (g69 g1520))
-                                                                ((top-level-value
-                                                                   'syntax-error)
-                                                                  g1563
-                                                                  '"invalid definition in read-only environment")
-                                                                (#%void))
-                                                            (g169
-                                                              g1517
-                                                              (case-lambda
-                                                                [()
-                                                                 ((case-lambda
-                                                                    [(g1566)
-                                                                     ((case-lambda
-                                                                        [(g1567)
-                                                                         (if ((top-level-value
-                                                                                'memv)
-                                                                               g1567
-                                                                               '($module))
-                                                                             (g165
-                                                                               g1564
-                                                                               g1520
-                                                                               g1565
-                                                                               (g131
-                                                                                 (g26 g1566)))
-                                                                             (if ((top-level-value
-                                                                                    'memv)
-                                                                                   g1567
-                                                                                   '(displaced-lexical))
-                                                                                 (g34 g1565)
-                                                                                 ((top-level-value
-                                                                                    'syntax-error)
-                                                                                   g1565
-                                                                                   '"unknown module")))])
-                                                                       (g25 g1566))])
-                                                                   (g36 (g110
-                                                                          g1565
-                                                                          '(()))
-                                                                        '()))])))]))
-                                                     (if ((top-level-value
-                                                            'memv)
-                                                           g1528
-                                                           '(alias-form))
-                                                         ((top-level-value
-                                                            'call-with-values)
-                                                           (case-lambda
-                                                             [()
-                                                              (g190
-                                                                g1525
-                                                                g1526
-                                                                g1527)])
-                                                           (case-lambda
-                                                             [(g1568 g1569)
-                                                              ((case-lambda
-                                                                 [(g1570)
-                                                                  (begin
-                                                                    (if (g33 g1570
-                                                                             g1515)
-                                                                        (g34 g1570)
-                                                                        (#%void))
-                                                                    (if ((top-level-value
-                                                                           'not)
-                                                                          (g69 g1520))
-                                                                        ((top-level-value
-                                                                           'syntax-error)
-                                                                          (g120
-                                                                            g1525
-                                                                            g1526
-                                                                            g1527)
-                                                                          '"invalid definition in read-only environment")
-                                                                        (#%void))
-                                                                    ((case-lambda
-                                                                       [(g1571)
-                                                                        ((top-level-value
-                                                                           'call-with-values)
-                                                                          (case-lambda
-                                                                            [()
-                                                                             (g105
-                                                                               g1571
-                                                                               (g46 (g4 g1570))
-                                                                               g1520)])
-                                                                          (case-lambda
-                                                                            [(g1572
-                                                                              g1573)
-                                                                             (begin
-                                                                               (if ((top-level-value
-                                                                                      'not)
-                                                                                     ((top-level-value
-                                                                                        'eq?)
-                                                                                       (g110
-                                                                                         g1570
-                                                                                         '(()))
-                                                                                       g1572))
-                                                                                   ((top-level-value
-                                                                                      'syntax-error)
-                                                                                     (g120
-                                                                                       g1525
-                                                                                       g1526
-                                                                                       g1527)
-                                                                                     '"definition not permitted")
-                                                                                   (#%void))
-                                                                               (if (g15 g1572)
-                                                                                   ((top-level-value
-                                                                                      'syntax-error)
-                                                                                     (g120
-                                                                                       g1525
-                                                                                       g1526
-                                                                                       g1527)
-                                                                                     '"invalid definition of read-only identifier")
-                                                                                   (#%void))
-                                                                               (g169
-                                                                                 g1517
-                                                                                 (case-lambda
-                                                                                   [()
-                                                                                    ((top-level-value
-                                                                                       'list)
-                                                                                      '#%$sc-put-cte
-                                                                                      ((top-level-value
-                                                                                         'list)
-                                                                                        'quote
-                                                                                        (g94 g1571
-                                                                                             (g46 (g4 g1570))
-                                                                                             (g110
-                                                                                               g1569
-                                                                                               g1526)))
-                                                                                      ((top-level-value
-                                                                                         'list)
-                                                                                        'quote
-                                                                                        '(do-alias
-                                                                                           .
-                                                                                           #f))
-                                                                                      ((top-level-value
-                                                                                         'list)
-                                                                                        'quote
-                                                                                        (g68 g1520)))])))]))])
-                                                                      ((case-lambda
-                                                                         [(g1574)
-                                                                          ((case-lambda
-                                                                             [(g1575)
-                                                                              (if (g7 g1575)
-                                                                                  ((top-level-value
-                                                                                     'annotation-expression)
-                                                                                    g1575)
-                                                                                  g1575)])
-                                                                            (if (g2 g1574)
-                                                                                (g3 g1574)
-                                                                                g1574))])
-                                                                        g1570)))])
-                                                                (g119
-                                                                  g1568
-                                                                  g1526))]))
-                                                         (begin
-                                                           (if g1522
-                                                               ((top-level-value
-                                                                  'syntax-error)
-                                                                 (g120
-                                                                   g1525
-                                                                   g1526
-                                                                   g1527)
-                                                                 '"invalid meta definition")
-                                                               (#%void))
-                                                           (if g1519
-                                                               ((case-lambda
-                                                                  [(g1576)
-                                                                   (begin
-                                                                     (g8 g1576)
-                                                                     (g170
-                                                                       g1517
-                                                                       (top-level-value
-                                                                         'void)
-                                                                       (case-lambda
-                                                                         [()
-                                                                          g1576])))])
-                                                                 (g175
-                                                                   g1523
-                                                                   g1524
-                                                                   g1525
-                                                                   g1515
-                                                                   g1515
-                                                                   g1526
-                                                                   g1527
-                                                                   '#t))
-                                                               (g168
-                                                                 g1518
-                                                                 (case-lambda
-                                                                   [()
-                                                                    (g175
-                                                                      g1523
-                                                                      g1524
-                                                                      g1525
-                                                                      g1515
-                                                                      g1515
-                                                                      g1526
-                                                                      g1527
-                                                                      '#f)])))))))))))))])
-                   g1523)]))])
-         (case-lambda
-           [(g1577)
-            (((case-lambda
-                [(g1578)
-                 ((case-lambda [(g1579) (begin (set! g1578 g1579) g1578)])
-                   (case-lambda
-                     [(g1580 g1581)
-                      (if ((top-level-value 'null?) g1580)
-                          g1581
-                          (g1578
-                            ((top-level-value 'cdr) g1580)
-                            (if ((top-level-value 'pair?)
-                                  ((top-level-value 'car) g1580))
-                                (g1578
-                                  ((top-level-value 'car) g1580)
-                                  g1581)
-                                ((top-level-value 'cons)
-                                  ((top-level-value 'car) g1580)
-                                  g1581))))]))])
-               (void))
-              g1577
-              '())])
-         (case-lambda
-           [(g1582 g1583 g1584)
-            ((top-level-value 'vector) 'interface g1582 g1583 g1584)])
-         (case-lambda
-           [(g1585)
-            (if ((top-level-value 'vector?) g1585)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1585)
-                      '4)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1585 '0)
-                      'interface)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1586) ((top-level-value 'vector-ref) g1586 '1)])
-         (case-lambda
-           [(g1587) ((top-level-value 'vector-ref) g1587 '2)])
-         (case-lambda
-           [(g1588) ((top-level-value 'vector-ref) g1588 '3)])
-         (case-lambda
-           [(g1589 g1590)
-            ((top-level-value 'vector-set!) g1589 '1 g1590)])
-         (case-lambda
-           [(g1591 g1592)
-            ((top-level-value 'vector-set!) g1591 '2 g1592)])
-         (case-lambda
-           [(g1593 g1594)
-            ((top-level-value 'vector-set!) g1593 '3 g1594)])
-         (case-lambda
-           [(g1595 g1596)
-            (g127
-              (g46 (g4 g1595))
-              ((top-level-value 'list->vector)
-                ((top-level-value 'map)
-                  (case-lambda
-                    [(g1597)
-                     (if ((top-level-value 'pair?) g1597)
-                         ((top-level-value 'car) g1597)
-                         g1597)])
-                  g1596))
-              '#f)])
-         (case-lambda
-           [(g1598 g1599 g1600)
-            (g127
-              (g46 (g4 g1598))
-              ((top-level-value 'list->vector)
-                ((top-level-value 'map)
-                  (case-lambda
-                    [(g1601)
-                     (g95 (if ((top-level-value 'pair?) g1601)
-                              ((top-level-value 'car) g1601)
-                              g1601))])
-                  g1599))
-              g1600)])
-         (case-lambda
-           [(g1602 g1603 g1604 g1605 g1606 g1607)
-            ((top-level-value 'vector) 'module-binding g1602 g1603 g1604
-              g1605 g1606 g1607)])
-         (case-lambda
-           [(g1608)
-            (if ((top-level-value 'vector?) g1608)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1608)
-                      '7)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1608 '0)
-                      'module-binding)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1609) ((top-level-value 'vector-ref) g1609 '1)])
-         (case-lambda
-           [(g1610) ((top-level-value 'vector-ref) g1610 '2)])
-         (case-lambda
-           [(g1611) ((top-level-value 'vector-ref) g1611 '3)])
-         (case-lambda
-           [(g1612) ((top-level-value 'vector-ref) g1612 '4)])
-         (case-lambda
-           [(g1613) ((top-level-value 'vector-ref) g1613 '5)])
-         (case-lambda
-           [(g1614) ((top-level-value 'vector-ref) g1614 '6)])
-         (case-lambda
-           [(g1615 g1616)
-            ((top-level-value 'vector-set!) g1615 '1 g1616)])
-         (case-lambda
-           [(g1617 g1618)
-            ((top-level-value 'vector-set!) g1617 '2 g1618)])
-         (case-lambda
-           [(g1619 g1620)
-            ((top-level-value 'vector-set!) g1619 '3 g1620)])
-         (case-lambda
-           [(g1621 g1622)
-            ((top-level-value 'vector-set!) g1621 '4 g1622)])
-         (case-lambda
-           [(g1623 g1624)
-            ((top-level-value 'vector-set!) g1623 '5 g1624)])
-         (case-lambda
-           [(g1625 g1626)
-            ((top-level-value 'vector-set!) g1625 '6 g1626)])
-         (case-lambda
-           [(g1627 g1628 g1629 g1630 g1631)
-            (g137 g1627 g1628 g1629 g1630 g1631 '#f)])
-         (case-lambda
-           [(g1632 g1633)
-            ((top-level-value 'vector) 'frob g1632 g1633)])
-         (case-lambda
-           [(g1634)
-            (if ((top-level-value 'vector?) g1634)
-                (if ((top-level-value 'fx=)
-                      ((top-level-value 'vector-length) g1634)
-                      '3)
-                    ((top-level-value 'eq?)
-                      ((top-level-value 'vector-ref) g1634 '0)
-                      'frob)
-                    '#f)
-                '#f)])
-         (case-lambda
-           [(g1635) ((top-level-value 'vector-ref) g1635 '1)])
-         (case-lambda
-           [(g1636) ((top-level-value 'vector-ref) g1636 '2)])
-         (case-lambda
-           [(g1637 g1638)
-            ((top-level-value 'vector-set!) g1637 '1 g1638)])
-         (case-lambda
-           [(g1639 g1640)
-            ((top-level-value 'vector-set!) g1639 '2 g1640)])
-         (case-lambda
-           [(g1641 g1642 g1643 g1644 g1645 g1646 g1647 g1648 g1649
-             g1650 g1651 g1652)
-            ((case-lambda
-               [(g1653)
-                ((top-level-value 'call-with-values)
-                  (case-lambda
-                    [()
-                     (g162 g1645 g1641
-                       ((top-level-value 'map)
-                         (case-lambda [(g1654) (g152 g1654 g1648)])
-                         g1651)
-                       g1642 g1643 g1646 g1650 g1653 g1652)])
-                  (case-lambda
-                    [(g1655 g1656 g1657 g1658)
-                     (((case-lambda
-                         [(g1659)
-                          ((case-lambda
-                             [(g1660) (begin (set! g1659 g1660) g1659)])
-                            (case-lambda
-                              [(g1661 g1662)
-                               (if ((top-level-value 'null?) g1661)
-                                   (((case-lambda
-                                       [(g1663)
-                                        ((case-lambda
-                                           [(g1664)
-                                            (begin
-                                              (set! g1663 g1664)
-                                              g1663)])
-                                          (case-lambda
-                                            [(g1665 g1666 g1667 g1668
-                                              g1669)
-                                             (if ((top-level-value 'null?)
-                                                   g1665)
-                                                 ((case-lambda
-                                                    [(g1670 g1671)
-                                                     (g20 '#f
-                                                          ((top-level-value
-                                                             'append)
-                                                            (g1662)
-                                                            ((top-level-value
-                                                               'list)
-                                                              (g169
-                                                                g1646
-                                                                (case-lambda
-                                                                  [()
-                                                                   ((case-lambda
-                                                                      [(g1672)
-                                                                       ((case-lambda
-                                                                          [(g1673)
-                                                                           ((case-lambda
-                                                                              [(g1674)
-                                                                               ((case-lambda
-                                                                                  [()
-                                                                                   ((top-level-value
-                                                                                      'call-with-values)
-                                                                                     (case-lambda
-                                                                                       [()
-                                                                                        (g105
-                                                                                          g1672
-                                                                                          (g46 (g4 g1649))
-                                                                                          g1644)])
-                                                                                     (case-lambda
-                                                                                       [(g1675
-                                                                                         g1676)
-                                                                                        (begin
-                                                                                          (if ((top-level-value
-                                                                                                 'not)
-                                                                                                ((top-level-value
-                                                                                                   'eq?)
-                                                                                                  (g110
-                                                                                                    g1649
-                                                                                                    '(()))
-                                                                                                  g1675))
-                                                                                              ((top-level-value
-                                                                                                 'syntax-error)
-                                                                                                g1641
-                                                                                                '"definition not permitted")
-                                                                                              (#%void))
-                                                                                          (if (g15 g1675)
-                                                                                              ((top-level-value
-                                                                                                 'syntax-error)
-                                                                                                g1641
-                                                                                                '"invalid definition of read-only identifier")
-                                                                                              (#%void))
-                                                                                          ((top-level-value
-                                                                                             'list)
-                                                                                            '#%$sc-put-cte
-                                                                                            ((top-level-value
-                                                                                               'list)
-                                                                                              'quote
-                                                                                              g1676)
-                                                                                            g1674
-                                                                                            ((top-level-value
-                                                                                               'list)
-                                                                                              'quote
-                                                                                              (g68 g1644))))]))]))])
-                                                                             ((top-level-value
-                                                                                'list)
-                                                                               'quote
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 '$module
-                                                                                 (g136
-                                                                                   g1649
-                                                                                   g1650
-                                                                                   g1673))))])
-                                                                         (g18 g1672))])
-                                                                     ((case-lambda
-                                                                        [(g1677)
-                                                                         ((case-lambda
-                                                                            [(g1678)
-                                                                             (if (g7 g1678)
-                                                                                 ((top-level-value
-                                                                                    'annotation-expression)
-                                                                                   g1678)
-                                                                                 g1678)])
-                                                                           (if (g2 g1677)
-                                                                               (g3 g1677)
-                                                                               g1677))])
-                                                                       g1649))]))
-                                                              (g168
-                                                                g1647
-                                                                (case-lambda
-                                                                  [()
-                                                                   (g23 '#f
-                                                                        g1667
-                                                                        g1668
-                                                                        g1670
-                                                                        (if ((top-level-value
-                                                                               'null?)
-                                                                              g1671)
-                                                                            (g194)
-                                                                            (g20 '#f
-                                                                                 ((top-level-value
-                                                                                    'append)
-                                                                                   g1671
-                                                                                   ((top-level-value
-                                                                                      'list)
-                                                                                     (g194))))))])))))])
-                                                   (g171
-                                                     g1669
-                                                     g1666
-                                                     g1656
-                                                     '#f)
-                                                   (g171
-                                                     g1658
-                                                     g1666
-                                                     g1656
-                                                     '#f))
-                                                 ((case-lambda
-                                                    [(g1679 g1680)
-                                                     ((case-lambda
-                                                        [(g1681)
-                                                         ((case-lambda
-                                                            [(g1682)
-                                                             (if ((top-level-value
-                                                                    'memv)
-                                                                   g1682
-                                                                   '(define-form))
-                                                                 ((case-lambda
-                                                                    [(g1683)
-                                                                     (if (g144
-                                                                           g1679)
-                                                                         ((case-lambda
-                                                                            [(g1684)
-                                                                             (g1663
-                                                                               g1680
-                                                                               g1666
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 'global
-                                                                                 g1667)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 g1683
-                                                                                 g1668)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 (g143
-                                                                                   g1679)
-                                                                                 g1669))])
-                                                                           (g140
-                                                                             g1679))
-                                                                         ((case-lambda
-                                                                            [(g1685)
-                                                                             (g1663
-                                                                               g1680
-                                                                               (g30 g1683
-                                                                                    ((top-level-value
-                                                                                       'cons)
-                                                                                      'lexical
-                                                                                      g1685)
-                                                                                    g1666)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 'local
-                                                                                 g1667)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 g1685
-                                                                                 g1668)
-                                                                               ((top-level-value
-                                                                                  'cons)
-                                                                                 (g143
-                                                                                   g1679)
-                                                                                 g1669))])
-                                                                           (g199
-                                                                             (g140
-                                                                               g1679))))])
-                                                                   (g53 (g141
-                                                                          g1679)))
-                                                                 (if ((top-level-value
-                                                                        'memv)
-                                                                       g1682
-                                                                       '(ctdefine-form
-                                                                          define-syntax-form
-                                                                          $module-form
-                                                                          alias-form))
-                                                                     (g1663
-                                                                       g1680
-                                                                       g1666
-                                                                       g1667
-                                                                       g1668
-                                                                       g1669)
-                                                                     ((top-level-value
-                                                                        'error)
-                                                                       'sc-expand-internal
-                                                                       '"unexpected module binding type ~s"
-                                                                       g1681)))])
-                                                           (g139 g1679))])
-                                                       (g139 g1679))])
-                                                   ((top-level-value 'car)
-                                                     g1665)
-                                                   ((top-level-value 'cdr)
-                                                     g1665)))]))])
-                                      (void)) g1657 g1655 '() '() '())
-                                   ((case-lambda
-                                      [(g1686 g1687)
-                                       (((case-lambda
-                                           [(g1688)
-                                            ((case-lambda
-                                               [(g1689)
-                                                (begin
-                                                  (set! g1688 g1689)
-                                                  g1688)])
-                                              (case-lambda
-                                                [(g1690)
-                                                 (if ((top-level-value
-                                                        'null?)
-                                                       g1690)
-                                                     (g1659 g1687 g1662)
-                                                     ((case-lambda
-                                                        [(g1691 g1692)
-                                                         (if (g111
-                                                               (g140 g1691)
-                                                               g1686)
-                                                             (if (g144
-                                                                   g1691)
-                                                                 (g1659
-                                                                   g1687
-                                                                   g1662)
-                                                                 ((case-lambda
-                                                                    [(g1693)
-                                                                     ((case-lambda
-                                                                        [(g1694)
-                                                                         ((case-lambda
-                                                                            [(g1695)
-                                                                             ((case-lambda
-                                                                                [(g1696)
-                                                                                 ((case-lambda
-                                                                                    [()
-                                                                                     (begin
-                                                                                       (g150
-                                                                                         g1691
-                                                                                         '#t)
-                                                                                       ((case-lambda
-                                                                                          [(g1697)
-                                                                                           (if ((top-level-value
-                                                                                                  'memv)
-                                                                                                 g1697
-                                                                                                 '(define-form))
-                                                                                               ((case-lambda
-                                                                                                  [(g1698)
-                                                                                                   (begin
-                                                                                                     (g54 g1694
-                                                                                                          g1698)
-                                                                                                     (g1659
-                                                                                                       g1696
-                                                                                                       g1662))])
-                                                                                                 (g18 ((case-lambda
-                                                                                                         [(g1699)
-                                                                                                          ((case-lambda
-                                                                                                             [(g1700)
-                                                                                                              (if (g7 g1700)
-                                                                                                                  ((top-level-value
-                                                                                                                     'annotation-expression)
-                                                                                                                    g1700)
-                                                                                                                  g1700)])
-                                                                                                            (if (g2 g1699)
-                                                                                                                (g3 g1699)
-                                                                                                                g1699))])
-                                                                                                        g1686)))
-                                                                                               (if ((top-level-value
-                                                                                                      'memv)
-                                                                                                     g1697
-                                                                                                     '(ctdefine-form))
-                                                                                                   ((case-lambda
-                                                                                                      [(g1701)
-                                                                                                       (g1659
-                                                                                                         g1696
-                                                                                                         (case-lambda
-                                                                                                           [()
-                                                                                                            ((case-lambda
-                                                                                                               [(g1702)
-                                                                                                                (begin
-                                                                                                                  (g54 g1694
-                                                                                                                       g1702)
-                                                                                                                  ((top-level-value
-                                                                                                                     'cons)
-                                                                                                                    (g170
-                                                                                                                      g1646
-                                                                                                                      (case-lambda
-                                                                                                                        [()
-                                                                                                                         (g12 g1702
-                                                                                                                              g1701)])
-                                                                                                                      (case-lambda
-                                                                                                                        [()
-                                                                                                                         ((top-level-value
-                                                                                                                            'list)
-                                                                                                                           '#%$sc-put-cte
-                                                                                                                           ((top-level-value
-                                                                                                                              'list)
-                                                                                                                             'quote
-                                                                                                                             g1702)
-                                                                                                                           ((top-level-value
-                                                                                                                              'list)
-                                                                                                                             'quote
-                                                                                                                             g1701)
-                                                                                                                           ((top-level-value
-                                                                                                                              'list)
-                                                                                                                             'quote
-                                                                                                                             '#f))]))
-                                                                                                                    (g1662)))])
-                                                                                                              (g26 g1701))]))])
-                                                                                                     (g143
-                                                                                                       g1691))
-                                                                                                   (if ((top-level-value
-                                                                                                          'memv)
-                                                                                                         g1697
-                                                                                                         '(define-syntax-form))
-                                                                                                       ((case-lambda
-                                                                                                          [(g1703)
-                                                                                                           (g1659
-                                                                                                             g1696
-                                                                                                             (case-lambda
-                                                                                                               [()
-                                                                                                                ((case-lambda
-                                                                                                                   [(g1704)
-                                                                                                                    (begin
-                                                                                                                      (g54 g1694
-                                                                                                                           g1703)
-                                                                                                                      ((top-level-value
-                                                                                                                         'cons)
-                                                                                                                        (g170
-                                                                                                                          g1646
-                                                                                                                          (case-lambda
-                                                                                                                            [()
-                                                                                                                             (g12 g1703
-                                                                                                                                  ((top-level-value
-                                                                                                                                     'car)
-                                                                                                                                    (g143
-                                                                                                                                      g1691)))])
-                                                                                                                          (case-lambda
-                                                                                                                            [()
-                                                                                                                             ((top-level-value
-                                                                                                                                'list)
-                                                                                                                               '#%$sc-put-cte
-                                                                                                                               ((top-level-value
-                                                                                                                                  'list)
-                                                                                                                                 'quote
-                                                                                                                                 g1703)
-                                                                                                                               ((top-level-value
-                                                                                                                                  'cdr)
-                                                                                                                                 (g143
-                                                                                                                                   g1691))
-                                                                                                                               ((top-level-value
-                                                                                                                                  'list)
-                                                                                                                                 'quote
-                                                                                                                                 '#f))]))
-                                                                                                                        (g1662)))])
-                                                                                                                  (g53 g1694))]))])
-                                                                                                         (g18 ((case-lambda
-                                                                                                                 [(g1705)
-                                                                                                                  ((case-lambda
-                                                                                                                     [(g1706)
-                                                                                                                      (if (g7 g1706)
-                                                                                                                          ((top-level-value
-                                                                                                                             'annotation-expression)
-                                                                                                                            g1706)
-                                                                                                                          g1706)])
-                                                                                                                    (if (g2 g1705)
-                                                                                                                        (g3 g1705)
-                                                                                                                        g1705))])
-                                                                                                                g1686)))
-                                                                                                       (if ((top-level-value
-                                                                                                              'memv)
-                                                                                                             g1697
-                                                                                                             '($module-form))
-                                                                                                           ((case-lambda
-                                                                                                              [(g1707
-                                                                                                                g1708)
-                                                                                                               (g1659
-                                                                                                                 ((top-level-value
-                                                                                                                    'append)
-                                                                                                                   (g126
-                                                                                                                     g1708)
-                                                                                                                   g1696)
-                                                                                                                 (case-lambda
-                                                                                                                   [()
-                                                                                                                    (begin
-                                                                                                                      (g54 g1694
-                                                                                                                           g1707)
-                                                                                                                      ((case-lambda
-                                                                                                                         [(g1709)
-                                                                                                                          ((case-lambda
-                                                                                                                             [(g1710)
-                                                                                                                              ((top-level-value
-                                                                                                                                 'cons)
-                                                                                                                                (g170
-                                                                                                                                  g1646
-                                                                                                                                  (case-lambda
-                                                                                                                                    [()
-                                                                                                                                     (g12 g1707
-                                                                                                                                          g1710)])
-                                                                                                                                  (case-lambda
-                                                                                                                                    [()
-                                                                                                                                     ((top-level-value
-                                                                                                                                        'list)
-                                                                                                                                       '#%$sc-put-cte
-                                                                                                                                       ((top-level-value
-                                                                                                                                          'list)
-                                                                                                                                         'quote
-                                                                                                                                         g1707)
-                                                                                                                                       ((top-level-value
-                                                                                                                                          'list)
-                                                                                                                                         'quote
-                                                                                                                                         g1710)
-                                                                                                                                       ((top-level-value
-                                                                                                                                          'list)
-                                                                                                                                         'quote
-                                                                                                                                         '#f))]))
-                                                                                                                                g1709)])
-                                                                                                                            ((top-level-value
-                                                                                                                               'cons)
-                                                                                                                              '$module
-                                                                                                                              (g136
-                                                                                                                                g1686
-                                                                                                                                g1708
-                                                                                                                                g1707)))])
-                                                                                                                        (g1662)))]))])
-                                                                                                             (g18 ((case-lambda
-                                                                                                                     [(g1711)
-                                                                                                                      ((case-lambda
-                                                                                                                         [(g1712)
-                                                                                                                          (if (g7 g1712)
-                                                                                                                              ((top-level-value
-                                                                                                                                 'annotation-expression)
-                                                                                                                                g1712)
-                                                                                                                              g1712)])
-                                                                                                                        (if (g2 g1711)
-                                                                                                                            (g3 g1711)
-                                                                                                                            g1711))])
-                                                                                                                    g1686))
-                                                                                                             (g143
-                                                                                                               g1691))
-                                                                                                           (if ((top-level-value
-                                                                                                                  'memv)
-                                                                                                                 g1697
-                                                                                                                 '(alias-form))
-                                                                                                               (g1659
-                                                                                                                 g1696
-                                                                                                                 (case-lambda
-                                                                                                                   [()
-                                                                                                                    ((case-lambda
-                                                                                                                       [(g1713)
-                                                                                                                        (begin
-                                                                                                                          (if (g49 g1694)
-                                                                                                                              (if ((top-level-value
-                                                                                                                                     'not)
-                                                                                                                                    ((top-level-value
-                                                                                                                                       'symbol?)
-                                                                                                                                      (g53 g1694)))
-                                                                                                                                  ((top-level-value
-                                                                                                                                     'syntax-error)
-                                                                                                                                    (g140
-                                                                                                                                      g1691)
-                                                                                                                                    '"unexported target of alias")
-                                                                                                                                  (#%void))
-                                                                                                                              (#%void))
-                                                                                                                          g1713)])
-                                                                                                                      (g1662))]))
-                                                                                                               ((top-level-value
-                                                                                                                  'error)
-                                                                                                                 'sc-expand-internal
-                                                                                                                 '"unexpected module binding type ~s"
-                                                                                                                 g1693))))))])
-                                                                                         g1693))]))])
-                                                                               ((top-level-value
-                                                                                  'append)
-                                                                                 g1695
-                                                                                 g1687))])
-                                                                           (g142
-                                                                             g1691))])
-                                                                       (g141
-                                                                         g1691))])
-                                                                   (g139
-                                                                     g1691)))
-                                                             (g1688
-                                                               g1692))])
-                                                       ((top-level-value
-                                                          'car)
-                                                         g1690)
-                                                       ((top-level-value
-                                                          'cdr)
-                                                         g1690)))]))])
-                                          (void))
-                                         g1657)])
-                                     ((top-level-value 'car) g1661)
-                                     ((top-level-value 'cdr) g1661)))]))])
-                        (void))
-                       g1653
-                       (case-lambda [() '()]))]))])
-              (g126 g1650))])
-         (case-lambda
-           [(g1714 g1715)
-            (if ((top-level-value 'null?) g1714)
-                '()
-                (if (g118 ((top-level-value 'car) g1714) g1715)
-                    (g159 ((top-level-value 'cdr) g1714) g1715)
-                    ((top-level-value 'cons)
-                      ((top-level-value 'car) g1714)
-                      (g159 ((top-level-value 'cdr) g1714) g1715))))])
-         (case-lambda
-           [(g1716 g1717 g1718)
-            ((case-lambda
-               [(g1719)
-                ((case-lambda
-                   [(g1720)
-                    (begin
-                      (set! g1719 g1720)
-                      (((case-lambda
-                          [(g1721)
-                           ((case-lambda
-                              [(g1722) (begin (set! g1721 g1722) g1721)])
-                             (case-lambda
-                               [(g1723 g1724)
-                                (if ((top-level-value 'null?) g1723)
-                                    (if ((top-level-value 'not)
-                                          ((top-level-value 'null?) g1724))
-                                        ((top-level-value 'syntax-error)
-                                          ((top-level-value 'car) g1724)
-                                          (if ((top-level-value 'fx=)
-                                                ((top-level-value 'length)
-                                                  g1724)
-                                                '1)
-                                              '"missing definition for export"
-                                              '"missing definition for multiple exports, including"))
-                                        (#%void))
-                                    ((case-lambda
-                                       [(g1725 g1726)
-                                        (if (g1719 g1725 g1718)
-                                            (g1721 g1726 g1724)
-                                            (g1721
-                                              g1726
-                                              ((top-level-value 'cons)
-                                                g1725
-                                                g1724)))])
-                                      ((top-level-value 'car) g1723)
-                                      ((top-level-value 'cdr) g1723)))]))])
-                         (void))
-                        g1717
-                        '()))])
-                  (case-lambda
-                    [(g1727 g1728)
-                     ((top-level-value 'ormap)
-                       (case-lambda
-                         [(g1729)
-                          (if (g73 g1729)
-                              ((case-lambda
-                                 [(g1730 g1731)
-                                  ((case-lambda
-                                     [(g1732)
-                                      (if g1732
-                                          ((case-lambda
-                                             [(g1733)
-                                              (g91 ((case-lambda
-                                                      [(g1734)
-                                                       ((case-lambda
-                                                          [(g1735)
-                                                           (if (g7 g1735)
-                                                               ((top-level-value
-                                                                  'annotation-expression)
-                                                                 g1735)
-                                                               g1735)])
-                                                         (if (g2 g1734)
-                                                             (g3 g1734)
-                                                             g1734))])
-                                                     g1727)
-                                                   (g42 g1727)
-                                                   g1733
-                                                   g1731)])
-                                            g1732)
-                                          ((case-lambda
-                                             [(g1736)
-                                              (((case-lambda
-                                                  [(g1737)
-                                                   ((case-lambda
-                                                      [(g1738)
-                                                       (begin
-                                                         (set! g1737 g1738)
-                                                         g1737)])
-                                                     (case-lambda
-                                                       [(g1739)
-                                                        (if ((top-level-value
-                                                               'fx>=)
-                                                              g1739
-                                                              '0)
-                                                            ((case-lambda
-                                                               [(g1740)
-                                                                (if g1740
-                                                                    g1740
-                                                                    (g1737
-                                                                      ((top-level-value
-                                                                         'fx-)
-                                                                        g1739
-                                                                        '1)))])
-                                                              ((case-lambda
-                                                                 [(g1741)
-                                                                  (g113
-                                                                    ((case-lambda
-                                                                       [(g1742)
-                                                                        ((case-lambda
-                                                                           [(g1743)
-                                                                            (if (g7 g1743)
-                                                                                ((top-level-value
-                                                                                   'annotation-expression)
-                                                                                  g1743)
-                                                                                g1743)])
-                                                                          (if (g2 g1742)
-                                                                              (g3 g1742)
-                                                                              g1742))])
-                                                                      g1741)
-                                                                    (g99 g1731
-                                                                         (g42 g1741))
-                                                                    ((case-lambda
-                                                                       [(g1744)
-                                                                        ((case-lambda
-                                                                           [(g1745)
-                                                                            (if (g7 g1745)
-                                                                                ((top-level-value
-                                                                                   'annotation-expression)
-                                                                                  g1745)
-                                                                                g1745)])
-                                                                          (if (g2 g1744)
-                                                                              (g3 g1744)
-                                                                              g1744))])
-                                                                      g1727)
-                                                                    (g42 g1727))])
-                                                                ((top-level-value
-                                                                   'vector-ref)
-                                                                  g1736
-                                                                  g1739)))
-                                                            '#f)]))])
-                                                 (void))
-                                                ((top-level-value 'fx-)
-                                                  ((top-level-value
-                                                     'vector-length)
-                                                    g1736)
-                                                  '1))])
-                                            (g130 g1730)))])
-                                    (g131 g1730))])
-                                (g74 g1729)
-                                (g75 g1729))
-                              (g114 g1727 g1729))])
-                       g1728)]))])
-              (void))])
-         (case-lambda
-           [(g1746 g1747)
-            ((case-lambda
-               [(g1748 g1749 g1750)
-                ((case-lambda
-                   [(g1751 g1752 g1753)
-                    (begin
-                      (set! g1748 g1751)
-                      (set! g1749 g1752)
-                      (set! g1750 g1753)
-                      (if ((top-level-value 'not)
-                            ((top-level-value 'null?) g1747))
-                          (((case-lambda
-                              [(g1754)
-                               ((case-lambda
-                                  [(g1755)
-                                   (begin (set! g1754 g1755) g1754)])
-                                 (case-lambda
-                                   [(g1756 g1757 g1758)
-                                    (if ((top-level-value 'null?) g1757)
-                                        (if ((top-level-value 'not)
-                                              ((top-level-value 'null?)
-                                                g1758))
-                                            ((case-lambda
-                                               [(g1759)
-                                                ((top-level-value
-                                                   'syntax-error)
-                                                  g1746
-                                                  '"duplicate definition for "
-                                                  ((top-level-value
-                                                     'symbol->string)
-                                                    ((top-level-value 'car)
-                                                      g1759))
-                                                  '" in")])
-                                              ((top-level-value
-                                                 'syntax-object->datum)
-                                                g1758))
-                                            (#%void))
-                                        (((case-lambda
-                                            [(g1760)
-                                             ((case-lambda
-                                                [(g1761)
-                                                 (begin
-                                                   (set! g1760 g1761)
-                                                   g1760)])
-                                               (case-lambda
-                                                 [(g1762 g1763)
-                                                  (if ((top-level-value
-                                                         'null?)
-                                                        g1762)
-                                                      (g1754
-                                                        ((top-level-value
-                                                           'car)
-                                                          g1757)
-                                                        ((top-level-value
-                                                           'cdr)
-                                                          g1757)
-                                                        g1763)
-                                                      (g1760
-                                                        ((top-level-value
-                                                           'cdr)
-                                                          g1762)
-                                                        (g1749
-                                                          g1756
-                                                          ((top-level-value
-                                                             'car)
-                                                            g1762)
-                                                          g1763)))]))])
-                                           (void))
-                                          g1757
-                                          g1758))]))])
-                             (void))
-                            ((top-level-value 'car) g1747)
-                            ((top-level-value 'cdr) g1747)
-                            '())
-                          (#%void)))])
-                  (case-lambda
-                    [(g1764 g1765 g1766)
-                     ((case-lambda
-                        [(g1767)
-                         (((case-lambda
-                             [(g1768)
-                              ((case-lambda
-                                 [(g1769)
-                                  (begin (set! g1768 g1769) g1768)])
-                                (case-lambda
-                                  [(g1770 g1771)
-                                   (if ((top-level-value 'fx=) g1770 g1767)
-                                       g1771
-                                       (g1768
-                                         ((top-level-value 'fx+) g1770 '1)
-                                         (g1765
-                                           ((top-level-value 'vector-ref)
-                                             g1764
-                                             g1770)
-                                           g1771)))]))])
-                            (void))
-                           '0
-                           g1766)])
-                       ((top-level-value 'vector-length) g1764))])
-                  (case-lambda
-                    [(g1772 g1773 g1774)
-                     (if (g73 g1772)
-                         ((case-lambda
-                            [(g1775 g1776)
-                             (if (g73 g1773)
-                                 ((case-lambda
-                                    [(g1777 g1778)
-                                     ((case-lambda
-                                        [(g1779 g1780)
-                                         (if ((top-level-value 'fx>)
-                                               ((top-level-value
-                                                  'vector-length)
-                                                 g1779)
-                                               ((top-level-value
-                                                  'vector-length)
-                                                 g1780))
-                                             (g1748
-                                               g1780
-                                               (case-lambda
-                                                 [(g1781 g1782)
-                                                  (g1750 g1781 g1778 g1775
-                                                    g1776 g1782)])
-                                               g1774)
-                                             (g1748
-                                               g1779
-                                               (case-lambda
-                                                 [(g1783 g1784)
-                                                  (g1750 g1783 g1776 g1777
-                                                    g1778 g1784)])
-                                               g1774))])
-                                       (g130 g1775)
-                                       (g130 g1777))])
-                                   (g74 g1773)
-                                   (g75 g1773))
-                                 (g1750 g1773 '() g1775 g1776 g1774))])
-                           (g74 g1772)
-                           (g75 g1772))
-                         (if (g73 g1773)
-                             ((case-lambda
-                                [(g1785 g1786)
-                                 (g1750 g1772 '() g1785 g1786 g1774)])
-                               (g74 g1773)
-                               (g75 g1773))
-                             (if (g114 g1772 g1773)
-                                 ((top-level-value 'cons) g1772 g1774)
-                                 g1774)))])
-                  (case-lambda
-                    [(g1787 g1788 g1789 g1790 g1791)
-                     ((case-lambda
-                        [(g1792 g1793)
-                         ((case-lambda
-                            [(g1794)
-                             (if g1794
-                                 ((case-lambda
-                                    [(g1795)
-                                     (if (g91 g1792 g1793 g1795 g1790)
-                                         ((top-level-value 'cons)
-                                           g1787
-                                           g1791)
-                                         g1791)])
-                                   g1794)
-                                 (g1748
-                                   (g130 g1789)
-                                   (case-lambda
-                                     [(g1796 g1797)
-                                      ((case-lambda
-                                         [(g1798 g1799)
-                                          (if (g113
-                                                g1798
-                                                g1799
-                                                g1792
-                                                g1793)
-                                              ((top-level-value 'cons)
-                                                g1796
-                                                g1797)
-                                              g1797)])
-                                        ((case-lambda
-                                           [(g1800)
-                                            ((case-lambda
-                                               [(g1801)
-                                                (if (g7 g1801)
-                                                    ((top-level-value
-                                                       'annotation-expression)
-                                                      g1801)
-                                                    g1801)])
-                                              (if (g2 g1800)
-                                                  (g3 g1800)
-                                                  g1800))])
-                                          g1796)
-                                        (g99 g1790 (g42 g1796)))])
-                                   g1791))])
-                           (g131 g1789))])
-                       ((case-lambda
-                          [(g1802)
-                           ((case-lambda
-                              [(g1803)
-                               (if (g7 g1803)
-                                   ((top-level-value
-                                      'annotation-expression)
-                                     g1803)
-                                   g1803)])
-                             (if (g2 g1802) (g3 g1802) g1802))])
-                         g1787)
-                       (g99 g1788 (g42 g1787)))]))])
-              (void)
-              (void)
-              (void))])
-         (case-lambda
-           [(g1804 g1805 g1806 g1807 g1808 g1809 g1810 g1811 g1812)
-            ((case-lambda
-               [(g1813 g1814 g1815)
-                ((case-lambda
-                   [(g1816 g1817 g1818)
-                    (begin
-                      (set! g1813 g1816)
-                      (set! g1814 g1817)
-                      (set! g1815 g1818)
-                      (((case-lambda
-                          [(g1819)
-                           ((case-lambda
-                              [(g1820) (begin (set! g1819 g1820) g1819)])
-                             (case-lambda
-                               [(g1821 g1822 g1823 g1824 g1825 g1826 g1827)
-                                (if ((top-level-value 'null?) g1821)
-                                    (g1813 g1822 g1823 g1825 g1824 g1826)
-                                    ((case-lambda
-                                       [(g1828)
-                                        ((case-lambda
-                                           [(g1829)
-                                            ((case-lambda
-                                               [(g1830)
-                                                ((case-lambda
-                                                   [()
-                                                    ((top-level-value
-                                                       'call-with-values)
-                                                      (case-lambda
-                                                        [()
-                                                         (g122 g1829 g1822
-                                                           '(()) '#f
-                                                           g1804)])
-                                                      (case-lambda
-                                                        [(g1831 g1832 g1833
-                                                          g1834 g1835)
-                                                         ((case-lambda
-                                                            [(g1836)
-                                                             (if ((top-level-value
-                                                                    'memv)
-                                                                   g1836
-                                                                   '(define-form))
-                                                                 ((top-level-value
-                                                                    'call-with-values)
-                                                                   (case-lambda
-                                                                     [()
-                                                                      (g186
-                                                                        g1833
-                                                                        g1834
-                                                                        g1835)])
-                                                                   (case-lambda
-                                                                     [(g1837
-                                                                       g1838
-                                                                       g1839)
-                                                                      ((case-lambda
-                                                                         [(g1840)
-                                                                          ((case-lambda
-                                                                             [(g1841)
-                                                                              ((case-lambda
-                                                                                 [(g1842)
-                                                                                  ((case-lambda
-                                                                                     [(g1843)
-                                                                                      ((case-lambda
-                                                                                         [()
-                                                                                          (begin
-                                                                                            (g86 g1804
-                                                                                                 g1840
-                                                                                                 g1841)
-                                                                                            (if g1830
-                                                                                                ((case-lambda
-                                                                                                   [(g1844)
-                                                                                                    ((case-lambda
-                                                                                                       [(g1845)
-                                                                                                        ((case-lambda
-                                                                                                           [()
-                                                                                                            ((case-lambda
-                                                                                                               [(g1846)
-                                                                                                                ((case-lambda
-                                                                                                                   [(g1847)
-                                                                                                                    (begin
-                                                                                                                      (g10 g1844
-                                                                                                                           (g8 g1847))
-                                                                                                                      (g1812
-                                                                                                                        (g170
-                                                                                                                          g1809
-                                                                                                                          (top-level-value
-                                                                                                                            'void)
-                                                                                                                          (case-lambda
-                                                                                                                            [()
-                                                                                                                             ((top-level-value
-                                                                                                                                'list)
-                                                                                                                               'set-top-level-value!
-                                                                                                                               ((top-level-value
-                                                                                                                                  'list)
-                                                                                                                                 'quote
-                                                                                                                                 g1844)
-                                                                                                                               g1847)])))
-                                                                                                                      (g1819
-                                                                                                                        ((top-level-value
-                                                                                                                           'cdr)
-                                                                                                                          g1821)
-                                                                                                                        g1822
-                                                                                                                        g1846
-                                                                                                                        ((top-level-value
-                                                                                                                           'cons)
-                                                                                                                          g1840
-                                                                                                                          g1824)
-                                                                                                                        ((top-level-value
-                                                                                                                           'cons)
-                                                                                                                          (g151
-                                                                                                                            'ctdefine-form
-                                                                                                                            g1840
-                                                                                                                            g1841
-                                                                                                                            g1843
-                                                                                                                            g1845)
-                                                                                                                          g1825)
-                                                                                                                        g1826
-                                                                                                                        '#f))])
-                                                                                                                  (g174
-                                                                                                                    g1838
-                                                                                                                    g1846
-                                                                                                                    g1846
-                                                                                                                    g1839
-                                                                                                                    '#t))])
-                                                                                                              (g30 (g53 g1841)
-                                                                                                                   g1845
-                                                                                                                   g1823))]))])
-                                                                                                      ((top-level-value
-                                                                                                         'cons)
-                                                                                                        'meta-variable
-                                                                                                        g1844))])
-                                                                                                  (g18 ((case-lambda
-                                                                                                          [(g1848)
-                                                                                                           ((case-lambda
-                                                                                                              [(g1849)
-                                                                                                               (if (g7 g1849)
-                                                                                                                   ((top-level-value
-                                                                                                                      'annotation-expression)
-                                                                                                                     g1849)
-                                                                                                                   g1849)])
-                                                                                                             (if (g2 g1848)
-                                                                                                                 (g3 g1848)
-                                                                                                                 g1848))])
-                                                                                                         g1840)))
-                                                                                                (g1819
-                                                                                                  ((top-level-value
-                                                                                                     'cdr)
-                                                                                                    g1821)
-                                                                                                  g1822
-                                                                                                  g1823
-                                                                                                  ((top-level-value
-                                                                                                     'cons)
-                                                                                                    g1840
-                                                                                                    g1824)
-                                                                                                  ((top-level-value
-                                                                                                     'cons)
-                                                                                                    (g151
-                                                                                                      g1831
-                                                                                                      g1840
-                                                                                                      g1841
-                                                                                                      g1843
-                                                                                                      (g152
-                                                                                                        (g119
-                                                                                                          g1838
-                                                                                                          g1839)
-                                                                                                        g1830))
-                                                                                                    g1825)
-                                                                                                  g1826
-                                                                                                  '#f)))]))])
-                                                                                    (g1814
-                                                                                      g1840))])
-                                                                                (g18 ((case-lambda
-                                                                                        [(g1850)
-                                                                                         ((case-lambda
-                                                                                            [(g1851)
-                                                                                             (if (g7 g1851)
-                                                                                                 ((top-level-value
-                                                                                                    'annotation-expression)
-                                                                                                   g1851)
-                                                                                                 g1851)])
-                                                                                           (if (g2 g1850)
-                                                                                               (g3 g1850)
-                                                                                               g1850))])
-                                                                                       g1840)))])
-                                                                            (g52))])
-                                                                        (g119
-                                                                          g1837
-                                                                          g1839))]))
-                                                                 (if ((top-level-value
-                                                                        'memv)
-                                                                       g1836
-                                                                       '(define-syntax-form))
-                                                                     ((top-level-value
-                                                                        'call-with-values)
-                                                                       (case-lambda
-                                                                         [()
-                                                                          (g187
-                                                                            g1833
-                                                                            g1834
-                                                                            g1835)])
-                                                                       (case-lambda
-                                                                         [(g1852
-                                                                           g1853
-                                                                           g1854)
-                                                                          ((case-lambda
-                                                                             [(g1855)
-                                                                              ((case-lambda
-                                                                                 [(g1856)
-                                                                                  ((case-lambda
-                                                                                     [(g1857)
-                                                                                      ((case-lambda
-                                                                                         [(g1858)
-                                                                                          ((case-lambda
-                                                                                             [()
-                                                                                              (begin
-                                                                                                (g86 g1804
-                                                                                                     g1855
-                                                                                                     g1856)
-                                                                                                ((case-lambda
-                                                                                                   [(g1859
-                                                                                                     g1860)
-                                                                                                    (g1819
-                                                                                                      ((top-level-value
-                                                                                                         'cdr)
-                                                                                                        g1821)
-                                                                                                      (g30 g1859
-                                                                                                           g1860
-                                                                                                           g1822)
-                                                                                                      (g30 g1859
-                                                                                                           g1860
-                                                                                                           g1823)
-                                                                                                      ((top-level-value
-                                                                                                         'cons)
-                                                                                                        g1855
-                                                                                                        g1824)
-                                                                                                      ((top-level-value
-                                                                                                         'cons)
-                                                                                                        (g151
-                                                                                                          g1831
-                                                                                                          g1855
-                                                                                                          g1856
-                                                                                                          g1857
-                                                                                                          ((top-level-value
-                                                                                                             'cons)
-                                                                                                            g1860
-                                                                                                            g1858))
-                                                                                                        g1825)
-                                                                                                      g1826
-                                                                                                      '#f)])
-                                                                                                  (g53 g1856)
-                                                                                                  (g38 g8
-                                                                                                       g1858)))]))])
-                                                                                        (g174
-                                                                                          g1853
-                                                                                          g1823
-                                                                                          g1823
-                                                                                          g1854
-                                                                                          '#t))])
-                                                                                    (g1814
-                                                                                      g1855))])
-                                                                                (g52))])
-                                                                            (g119
-                                                                              g1852
-                                                                              g1854))]))
-                                                                     (if ((top-level-value
-                                                                            'memv)
-                                                                           g1836
-                                                                           '($module-form))
-                                                                         ((case-lambda
-                                                                            [(g1861)
-                                                                             ((case-lambda
-                                                                                [(g1862)
-                                                                                 ((case-lambda
-                                                                                    [()
-                                                                                     ((top-level-value
-                                                                                        'call-with-values)
-                                                                                       (case-lambda
-                                                                                         [()
-                                                                                          (g184
-                                                                                            g1833
-                                                                                            g1834
-                                                                                            g1835
-                                                                                            g1862)])
-                                                                                       (case-lambda
-                                                                                         [(g1863
-                                                                                           g1864
-                                                                                           g1865
-                                                                                           g1866)
-                                                                                          ((top-level-value
-                                                                                             'call-with-values)
-                                                                                            (case-lambda
-                                                                                              [()
-                                                                                               (g162
-                                                                                                 g1861
-                                                                                                 g1863
-                                                                                                 ((top-level-value
-                                                                                                    'map)
-                                                                                                   (case-lambda
-                                                                                                     [(g1867)
-                                                                                                      (g152
-                                                                                                        g1867
-                                                                                                        g1830)])
-                                                                                                   g1866)
-                                                                                                 g1822
-                                                                                                 g1823
-                                                                                                 g1809
-                                                                                                 g1865
-                                                                                                 (g126
-                                                                                                   g1865)
-                                                                                                 g1812)])
-                                                                                            (case-lambda
-                                                                                              [(g1868
-                                                                                                g1869
-                                                                                                g1870
-                                                                                                g1871)
-                                                                                               ((case-lambda
-                                                                                                  [(g1872
-                                                                                                    g1873
-                                                                                                    g1874
-                                                                                                    g1875
-                                                                                                    g1876)
-                                                                                                   (begin
-                                                                                                     (g86 g1804
-                                                                                                          g1864
-                                                                                                          g1875)
-                                                                                                     ((case-lambda
-                                                                                                        [(g1877
-                                                                                                          g1878)
-                                                                                                         (g1819
-                                                                                                           ((top-level-value
-                                                                                                              'cdr)
-                                                                                                             g1821)
-                                                                                                           (g30 g1877
-                                                                                                                g1878
-                                                                                                                g1868)
-                                                                                                           (g30 g1877
-                                                                                                                g1878
-                                                                                                                g1869)
-                                                                                                           ((top-level-value
-                                                                                                              'cons)
-                                                                                                             g1864
-                                                                                                             g1824)
-                                                                                                           ((top-level-value
-                                                                                                              'cons)
-                                                                                                             (g151
-                                                                                                               g1831
-                                                                                                               g1864
-                                                                                                               g1875
-                                                                                                               g1876
-                                                                                                               g1865)
-                                                                                                             g1873)
-                                                                                                           g1874
-                                                                                                           '#f)])
-                                                                                                       (g53 g1875)
-                                                                                                       ((top-level-value
-                                                                                                          'cons)
-                                                                                                         '$module
-                                                                                                         g1872)))])
-                                                                                                 (g135
-                                                                                                   g1864
-                                                                                                   g1865)
-                                                                                                 ((top-level-value
-                                                                                                    'append)
-                                                                                                   g1870
-                                                                                                   g1825)
-                                                                                                 ((top-level-value
-                                                                                                    'append)
-                                                                                                   g1826
-                                                                                                   g1871)
-                                                                                                 (g52)
-                                                                                                 (g1814
-                                                                                                   g1864))]))]))]))])
-                                                                               (g45 (g46 g1834)
-                                                                                    ((top-level-value
-                                                                                       'cons)
-                                                                                      g1861
-                                                                                      (g47 g1834))))])
-                                                                           (g58 '()
-                                                                                '()
-                                                                                '()))
-                                                                         (if ((top-level-value
-                                                                                'memv)
-                                                                               g1836
-                                                                               '($import-form))
-                                                                             ((top-level-value
-                                                                                'call-with-values)
-                                                                               (case-lambda
-                                                                                 [()
-                                                                                  (g185
-                                                                                    g1833
-                                                                                    g1834
-                                                                                    g1835)])
-                                                                               (case-lambda
-                                                                                 [(g1879
-                                                                                   g1880
-                                                                                   g1881)
-                                                                                  ((case-lambda
-                                                                                     [(g1882)
-                                                                                      ((case-lambda
-                                                                                         [(g1883)
-                                                                                          ((case-lambda
-                                                                                             [(g1884)
-                                                                                              (if ((top-level-value
-                                                                                                     'memv)
-                                                                                                    g1884
-                                                                                                    '($module))
-                                                                                                  ((case-lambda
-                                                                                                     [(g1885)
-                                                                                                      ((case-lambda
-                                                                                                         [(g1886)
-                                                                                                          ((case-lambda
-                                                                                                             [()
-                                                                                                              (begin
-                                                                                                                (if g1880
-                                                                                                                    (g88 g1804
-                                                                                                                         g1881)
-                                                                                                                    (#%void))
-                                                                                                                (g183
-                                                                                                                  g1886
-                                                                                                                  g1804)
-                                                                                                                (g1819
-                                                                                                                  ((top-level-value
-                                                                                                                     'cdr)
-                                                                                                                    g1821)
-                                                                                                                  g1822
-                                                                                                                  g1823
-                                                                                                                  ((top-level-value
-                                                                                                                     'cons)
-                                                                                                                    g1886
-                                                                                                                    g1824)
-                                                                                                                  (g1815
-                                                                                                                    g1825
-                                                                                                                    ((top-level-value
-                                                                                                                       'vector->list)
-                                                                                                                      (g130
-                                                                                                                        g1885)))
-                                                                                                                  g1826
-                                                                                                                  '#f))]))])
-                                                                                                        (g72 g1885
-                                                                                                             (g181
-                                                                                                               g1881
-                                                                                                               g1885)))])
-                                                                                                    (g26 g1883))
-                                                                                                  (if ((top-level-value
-                                                                                                         'memv)
-                                                                                                        g1884
-                                                                                                        '(displaced-lexical))
-                                                                                                      (g34 g1881)
-                                                                                                      ((top-level-value
-                                                                                                         'syntax-error)
-                                                                                                        g1881
-                                                                                                        '"unknown module")))])
-                                                                                            (g25 g1883))])
-                                                                                        (g36 g1882
-                                                                                             g1822))])
-                                                                                    (g110
-                                                                                      g1881
-                                                                                      '(())))]))
-                                                                             (if ((top-level-value
-                                                                                    'memv)
-                                                                                   g1836
-                                                                                   '(alias-form))
-                                                                                 ((top-level-value
-                                                                                    'call-with-values)
-                                                                                   (case-lambda
-                                                                                     [()
-                                                                                      (g190
-                                                                                        g1833
-                                                                                        g1834
-                                                                                        g1835)])
-                                                                                   (case-lambda
-                                                                                     [(g1887
-                                                                                       g1888)
-                                                                                      ((case-lambda
-                                                                                         [(g1889)
-                                                                                          ((case-lambda
-                                                                                             [(g1890)
-                                                                                              ((case-lambda
-                                                                                                 [(g1891)
-                                                                                                  ((case-lambda
-                                                                                                     [()
-                                                                                                      (begin
-                                                                                                        (g86 g1804
-                                                                                                             g1889
-                                                                                                             g1890)
-                                                                                                        (g1819
-                                                                                                          ((top-level-value
-                                                                                                             'cdr)
-                                                                                                            g1821)
-                                                                                                          g1822
-                                                                                                          g1823
-                                                                                                          ((top-level-value
-                                                                                                             'cons)
-                                                                                                            g1889
-                                                                                                            g1824)
-                                                                                                          ((top-level-value
-                                                                                                             'cons)
-                                                                                                            (g151
-                                                                                                              g1831
-                                                                                                              g1889
-                                                                                                              g1890
-                                                                                                              g1891
-                                                                                                              '#f)
-                                                                                                            g1825)
-                                                                                                          g1826
-                                                                                                          '#f))]))])
-                                                                                                (g1814
-                                                                                                  g1889))])
-                                                                                            (g109
-                                                                                              g1888
-                                                                                              g1834))])
-                                                                                        (g119
-                                                                                          g1887
-                                                                                          g1834))]))
-                                                                                 (if ((top-level-value
-                                                                                        'memv)
-                                                                                       g1836
-                                                                                       '(begin-form))
-                                                                                     (g1819
-                                                                                       (((case-lambda
-                                                                                           [(g1892)
-                                                                                            ((case-lambda
-                                                                                               [(g1893)
-                                                                                                (begin
-                                                                                                  (set! g1892
-                                                                                                    g1893)
-                                                                                                  g1892)])
-                                                                                              (case-lambda
-                                                                                                [(g1894)
-                                                                                                 (if ((top-level-value
-                                                                                                        'null?)
-                                                                                                       g1894)
-                                                                                                     ((top-level-value
-                                                                                                        'cdr)
-                                                                                                       g1821)
-                                                                                                     ((top-level-value
-                                                                                                        'cons)
-                                                                                                       (g152
-                                                                                                         (g119
-                                                                                                           ((top-level-value
-                                                                                                              'car)
-                                                                                                             g1894)
-                                                                                                           g1834)
-                                                                                                         g1830)
-                                                                                                       (g1892
-                                                                                                         ((top-level-value
-                                                                                                            'cdr)
-                                                                                                           g1894))))]))])
-                                                                                          (void))
-                                                                                         (g191
-                                                                                           g1833
-                                                                                           g1834
-                                                                                           g1835
-                                                                                           '#t))
-                                                                                       g1822
-                                                                                       g1823
-                                                                                       g1824
-                                                                                       g1825
-                                                                                       g1826
-                                                                                       '#f)
-                                                                                     (if ((top-level-value
-                                                                                            'memv)
-                                                                                           g1836
-                                                                                           '(eval-when-form))
-                                                                                         ((top-level-value
-                                                                                            'call-with-values)
-                                                                                           (case-lambda
-                                                                                             [()
-                                                                                              (g189
-                                                                                                g1833
-                                                                                                g1834
-                                                                                                g1835)])
-                                                                                           (case-lambda
-                                                                                             [(g1895
-                                                                                               g1896)
-                                                                                              (g1819
-                                                                                                (if ((top-level-value
-                                                                                                       'memq)
-                                                                                                      'eval
-                                                                                                      g1895)
-                                                                                                    (((case-lambda
-                                                                                                        [(g1897)
-                                                                                                         ((case-lambda
-                                                                                                            [(g1898)
-                                                                                                             (begin
-                                                                                                               (set! g1897
-                                                                                                                 g1898)
-                                                                                                               g1897)])
-                                                                                                           (case-lambda
-                                                                                                             [(g1899)
-                                                                                                              (if ((top-level-value
-                                                                                                                     'null?)
-                                                                                                                    g1899)
-                                                                                                                  ((top-level-value
-                                                                                                                     'cdr)
-                                                                                                                    g1821)
-                                                                                                                  ((top-level-value
-                                                                                                                     'cons)
-                                                                                                                    (g152
-                                                                                                                      (g119
-                                                                                                                        ((top-level-value
-                                                                                                                           'car)
-                                                                                                                          g1899)
-                                                                                                                        g1834)
-                                                                                                                      g1830)
-                                                                                                                    (g1897
-                                                                                                                      ((top-level-value
-                                                                                                                         'cdr)
-                                                                                                                        g1899))))]))])
-                                                                                                       (void))
-                                                                                                      g1896)
-                                                                                                    ((top-level-value
-                                                                                                       'cdr)
-                                                                                                      g1821))
-                                                                                                g1822
-                                                                                                g1823
-                                                                                                g1824
-                                                                                                g1825
-                                                                                                g1826
-                                                                                                '#f)]))
-                                                                                         (if ((top-level-value
-                                                                                                'memv)
-                                                                                               g1836
-                                                                                               '(meta-form))
-                                                                                             (g1819
-                                                                                               ((top-level-value
-                                                                                                  'cons)
-                                                                                                 (g152
-                                                                                                   (g119
-                                                                                                     (g188
-                                                                                                       g1833
-                                                                                                       g1834
-                                                                                                       g1835)
-                                                                                                     g1834)
-                                                                                                   '#t)
-                                                                                                 ((top-level-value
-                                                                                                    'cdr)
-                                                                                                   g1821))
-                                                                                               g1822
-                                                                                               g1823
-                                                                                               g1824
-                                                                                               g1825
-                                                                                               g1826
-                                                                                               '#t)
-                                                                                             (if ((top-level-value
-                                                                                                    'memv)
-                                                                                                   g1836
-                                                                                                   '(local-syntax-form))
-                                                                                                 ((top-level-value
-                                                                                                    'call-with-values)
-                                                                                                   (case-lambda
-                                                                                                     [()
-                                                                                                      (g193
-                                                                                                        g1832
-                                                                                                        g1833
-                                                                                                        g1822
-                                                                                                        g1823
-                                                                                                        g1834
-                                                                                                        g1835)])
-                                                                                                   (case-lambda
-                                                                                                     [(g1900
-                                                                                                       g1901
-                                                                                                       g1902
-                                                                                                       g1903
-                                                                                                       g1904)
-                                                                                                      (g1819
-                                                                                                        (((case-lambda
-                                                                                                            [(g1905)
-                                                                                                             ((case-lambda
-                                                                                                                [(g1906)
-                                                                                                                 (begin
-                                                                                                                   (set! g1905
-                                                                                                                     g1906)
-                                                                                                                   g1905)])
-                                                                                                               (case-lambda
-                                                                                                                 [(g1907)
-                                                                                                                  (if ((top-level-value
-                                                                                                                         'null?)
-                                                                                                                        g1907)
-                                                                                                                      ((top-level-value
-                                                                                                                         'cdr)
-                                                                                                                        g1821)
-                                                                                                                      ((top-level-value
-                                                                                                                         'cons)
-                                                                                                                        (g152
-                                                                                                                          (g119
-                                                                                                                            ((top-level-value
-                                                                                                                               'car)
-                                                                                                                              g1907)
-                                                                                                                            g1903)
-                                                                                                                          g1830)
-                                                                                                                        (g1905
-                                                                                                                          ((top-level-value
-                                                                                                                             'cdr)
-                                                                                                                            g1907))))]))])
-                                                                                                           (void))
-                                                                                                          g1900)
-                                                                                                        g1901
-                                                                                                        g1902
-                                                                                                        g1824
-                                                                                                        g1825
-                                                                                                        g1826
-                                                                                                        '#f)]))
-                                                                                                 (begin
-                                                                                                   (if g1827
-                                                                                                       ((top-level-value
-                                                                                                          'syntax-error)
-                                                                                                         (g120
-                                                                                                           g1833
-                                                                                                           g1834
-                                                                                                           g1835)
-                                                                                                         '"invalid meta definition")
-                                                                                                       (#%void))
-                                                                                                   (((case-lambda
-                                                                                                       [(g1908)
-                                                                                                        ((case-lambda
-                                                                                                           [(g1909)
-                                                                                                            (begin
-                                                                                                              (set! g1908
-                                                                                                                g1909)
-                                                                                                              g1908)])
-                                                                                                          (case-lambda
-                                                                                                            [(g1910)
-                                                                                                             (if ((case-lambda
-                                                                                                                    [(g1911)
-                                                                                                                     (if g1911
-                                                                                                                         g1911
-                                                                                                                         ((top-level-value
-                                                                                                                            'not)
-                                                                                                                           (g155
-                                                                                                                             ((top-level-value
-                                                                                                                                'car)
-                                                                                                                               g1910))))])
-                                                                                                                   ((top-level-value
-                                                                                                                      'null?)
-                                                                                                                     g1910))
-                                                                                                                 (g1813
-                                                                                                                   g1822
-                                                                                                                   g1823
-                                                                                                                   g1825
-                                                                                                                   g1824
-                                                                                                                   ((top-level-value
-                                                                                                                      'append)
-                                                                                                                     g1826
-                                                                                                                     g1910))
-                                                                                                                 (begin
-                                                                                                                   ((case-lambda
-                                                                                                                      [(g1912)
-                                                                                                                       (begin
-                                                                                                                         (g8 g1912)
-                                                                                                                         (g1812
-                                                                                                                           (g170
-                                                                                                                             g1809
-                                                                                                                             (top-level-value
-                                                                                                                               'void)
-                                                                                                                             (case-lambda
-                                                                                                                               [()
-                                                                                                                                g1912]))))])
-                                                                                                                     (g172
-                                                                                                                       ((top-level-value
-                                                                                                                          'car)
-                                                                                                                         g1910)
-                                                                                                                       g1823))
-                                                                                                                   (g1908
-                                                                                                                     ((top-level-value
-                                                                                                                        'cdr)
-                                                                                                                       g1910))))]))])
-                                                                                                      (void))
-                                                                                                     ((top-level-value
-                                                                                                        'cons)
-                                                                                                       (g152
-                                                                                                         (g120
-                                                                                                           g1833
-                                                                                                           g1834
-                                                                                                           g1835)
-                                                                                                         g1830)
-                                                                                                       ((top-level-value
-                                                                                                          'cdr)
-                                                                                                         g1821)))))))))))))])
-                                                           g1831)]))]))])
-                                              (g155 g1828))])
-                                          (g154 g1828))])
-                                      ((top-level-value 'car) g1821)))]))])
-                         (void)) g1806 g1807 g1808 '() '() '() '#f))])
-                  (case-lambda
-                    [(g1913 g1914 g1915 g1916 g1917)
-                     (begin
-                       (g161 g1805 g1916)
-                       (g160 g1805 g1811 g1916)
-                       ((top-level-value 'values)
-                         g1913
-                         g1914
-                         g1915
-                         g1917))])
-                  (case-lambda
-                    [(g1918)
-                     (((case-lambda
-                         [(g1919)
-                          ((case-lambda
-                             [(g1920) (begin (set! g1919 g1920) g1919)])
-                            (case-lambda
-                              [(g1921)
-                               (if ((top-level-value 'null?) g1921)
-                                   '()
-                                   (if (if ((top-level-value 'pair?)
-                                             ((top-level-value 'car)
-                                               g1921))
-                                           (g114
-                                             g1918
-                                             ((top-level-value 'caar)
-                                               g1921))
-                                           '#f)
-                                       (g126
-                                         ((top-level-value 'cdar) g1921))
-                                       (g1919
-                                         ((top-level-value 'cdr)
-                                           g1921))))]))])
-                        (void))
-                       g1810)])
-                  (case-lambda
-                    [(g1922 g1923)
-                     ((case-lambda
-                        [(g1924)
-                         ((top-level-value 'map)
-                           (case-lambda
-                             [(g1925)
-                              ((case-lambda
-                                 [(g1926)
-                                  (if ((top-level-value 'not)
-                                        (g118 g1926 g1924))
-                                      g1925
-                                      (g151 (g139 g1925) g1926 (g141 g1925)
-                                        ((top-level-value 'append)
-                                          (g1814 g1926)
-                                          (g142 g1925))
-                                        (g143 g1925)))])
-                                (g140 g1925))])
-                           g1922)])
-                       ((top-level-value 'map)
-                         (case-lambda
-                           [(g1927)
-                            (if ((top-level-value 'pair?) g1927)
-                                ((top-level-value 'car) g1927)
-                                g1927)])
-                         g1923))]))])
-              (void)
-              (void)
-              (void))])
-         (case-lambda
-           [(g1928 g1929)
-            (((case-lambda
-                [(g1930)
-                 ((case-lambda [(g1931) (begin (set! g1930 g1931) g1930)])
-                   (case-lambda
-                     [(g1932 g1933)
-                      (if ((top-level-value 'fx<) g1932 '0)
-                          g1933
-                          (g1930
-                            ((top-level-value 'fx-) g1932 '1)
-                            ((top-level-value 'cons)
-                              (g1928
-                                ((top-level-value 'vector-ref)
-                                  g1929
-                                  g1932))
-                              g1933)))]))])
-               (void))
-              ((top-level-value 'fx-)
-                ((top-level-value 'vector-length) g1929)
-                '1)
-              '())])
-         (case-lambda
-           [(g1934 g1935)
-            ((case-lambda
-               [(g1936)
-                (((case-lambda
-                    [(g1937)
-                     ((case-lambda
-                        [(g1938) (begin (set! g1937 g1938) g1937)])
-                       (case-lambda
-                         [(g1939)
-                          (if ((top-level-value 'not)
-                                ((top-level-value 'fx=) g1939 g1936))
-                              (begin
-                                (g1934
-                                  ((top-level-value 'vector-ref)
-                                    g1935
-                                    g1939))
-                                (g1937 ((top-level-value 'fx+) g1939 '1)))
-                              (#%void))]))])
-                   (void))
-                  '0)])
-              ((top-level-value 'vector-length) g1935))])
-         (case-lambda
-           [(g1940 g1941 g1942 g1943)
-            ((top-level-value 'list)
-              '#%$sc-put-cte
-              ((top-level-value 'list) 'quote g1942)
-              ((top-level-value 'list)
-                'quote
-                ((top-level-value 'cons) 'do-import g1943))
-              ((top-level-value 'list) 'quote (g68 g1941)))])
-         ((case-lambda
-            [(g1944)
-             (case-lambda
-               [(g1945 g1946)
-                ((case-lambda
-                   [(g1947)
-                    ((case-lambda
-                       [(g1948)
-                        (begin
-                          (set! g1947 g1948)
-                          (g1947
-                            '-
-                            ((top-level-value 'apply)
-                              (top-level-value 'append)
-                              ((top-level-value 'map)
-                                (case-lambda
-                                  [(g1949)
-                                   ((case-lambda
-                                      [(g1950)
-                                       ((top-level-value 'map)
-                                         (case-lambda
-                                           [(g1951)
-                                            ((top-level-value 'cdr)
-                                              ((top-level-value 'assq)
-                                                g1951
-                                                g1950))])
-                                         g1945)])
-                                     ((top-level-value 'cdr)
-                                       ((top-level-value 'assq)
-                                         g1949
-                                         g1944)))])
-                                g1946))))])
-                      (case-lambda
-                        [(g1952 g1953)
-                         (if ((top-level-value 'null?) g1953)
-                             '()
-                             (if ((top-level-value 'eq?)
-                                   ((top-level-value 'car) g1953)
-                                   g1952)
-                                 (g1947
-                                   g1952
-                                   ((top-level-value 'cdr) g1953))
-                                 ((top-level-value 'cons)
-                                   ((top-level-value 'car) g1953)
-                                   (g1947
-                                     g1952
-                                     ((top-level-value 'cdr)
-                                       g1953)))))]))])
-                  (void))])])
-           '((l (load . l) (compile . c) (visit . v) (revisit . r)
-                (eval . -))
-              (c (load . -) (compile . -) (visit . -) (revisit . -)
-                 (eval . c))
-              (v (load . v) (compile . c) (visit . v) (revisit . -)
-                 (eval . -))
-              (r (load . r) (compile . c) (visit . -) (revisit . r)
-                 (eval . -))
-              (e (load . -) (compile . -) (visit . -) (revisit . -)
-                 (eval . e))))
-         (case-lambda
-           [(g1954 g1955)
-            ((top-level-value 'apply)
-              (top-level-value 'append)
-              ((top-level-value 'map)
-                (case-lambda
-                  [(g1956)
-                   (if g1955
-                       ((case-lambda
-                          [(g1957)
-                           (if ((top-level-value 'memv) g1957 '(compile))
-                               '(c)
-                               (if ((top-level-value 'memv) g1957 '(load))
-                                   '(l)
-                                   (if ((top-level-value 'memv)
-                                         g1957
-                                         '(visit))
-                                       '(v)
-                                       (if ((top-level-value 'memv)
-                                             g1957
-                                             '(revisit))
-                                           '(r)
-                                           '()))))])
-                         g1956)
-                       ((case-lambda
-                          [(g1958)
-                           (if ((top-level-value 'memv) g1958 '(eval))
-                               '(e)
-                               '())])
-                         g1956))])
-                g1954))])
-         (case-lambda
-           [(g1959 g1960)
-            (if ((top-level-value 'memq) 'e g1959)
-                (g1960)
-                ((case-lambda
-                   [(g1961)
-                    (if ((top-level-value 'memq) 'v g1959)
-                        (if ((case-lambda
-                               [(g1962)
-                                (if g1962
-                                    g1962
-                                    ((top-level-value 'memq) 'r g1959))])
-                              ((top-level-value 'memq) 'l g1959))
-                            (g1961)
-                            (g1961))
-                        (if ((case-lambda
-                               [(g1963)
-                                (if g1963
-                                    g1963
-                                    ((top-level-value 'memq) 'r g1959))])
-                              ((top-level-value 'memq) 'l g1959))
-                            (g1961)
-                            (g194)))])
-                  (if ((top-level-value 'memq) 'c g1959)
-                      ((case-lambda
-                         [(g1964)
-                          (begin (g8 g1964) (case-lambda [() g1964]))])
-                        (g1960))
-                      g1960)))])
-         (case-lambda
-           [(g1965 g1966)
-            ((case-lambda
-               [(g1967)
-                (g170
-                  g1965
-                  (case-lambda
-                    [()
-                     (begin
-                       (if ((top-level-value 'not) g1967)
-                           (set! g1967 (g1966))
-                           (#%void))
-                       (g8 g1967))])
-                  (case-lambda
-                    [()
-                     ((case-lambda [(g1968) (if g1968 g1968 (g1966))])
-                       g1967)]))])
-              '#f)])
-         (case-lambda
-           [(g1969 g1970 g1971)
-            (if ((top-level-value 'memq) 'e g1969)
-                (begin (g1970) (g194))
-                (begin
-                  (if ((top-level-value 'memq) 'c g1969) (g1970) (#%void))
-                  (if ((top-level-value 'memq) 'r g1969)
-                      (if ((case-lambda
-                             [(g1972)
-                              (if g1972
-                                  g1972
-                                  ((top-level-value 'memq) 'v g1969))])
-                            ((top-level-value 'memq) 'l g1969))
-                          (g1971)
-                          (g1971))
-                      (if ((case-lambda
-                             [(g1973)
-                              (if g1973
-                                  g1973
-                                  ((top-level-value 'memq) 'v g1969))])
-                            ((top-level-value 'memq) 'l g1969))
-                          (g1971)
-                          (g194)))))])
-         (case-lambda
-           [(g1974 g1975 g1976 g1977)
-            ((top-level-value 'map)
-              (case-lambda
-                [(g1978) (g174 (g154 g1978) g1975 g1976 '(()) g1977)])
-              g1974)])
-         (case-lambda
-           [(g1979 g1980) (g174 (g154 g1979) g1980 g1980 '(()) '#t)])
-         (case-lambda
-           [(g1981 g1982 g1983 g1984 g1985 g1986)
-            (g20 g1985
-                 (((case-lambda
-                     [(g1987)
-                      ((case-lambda
-                         [(g1988) (begin (set! g1987 g1988) g1987)])
-                        (case-lambda
-                          [(g1989)
-                           (if ((top-level-value 'null?) g1989)
-                               '()
-                               ((case-lambda
-                                  [(g1990)
-                                   ((top-level-value 'cons)
-                                     g1990
-                                     (g1987
-                                       ((top-level-value 'cdr) g1989)))])
-                                 (g174 ((top-level-value 'car) g1989) g1982
-                                   g1983 g1984 g1986)))]))])
-                    (void))
-                   g1981))])
-         (case-lambda
-           [(g1991 g1992 g1993 g1994 g1995)
-            ((top-level-value 'call-with-values)
-              (case-lambda [() (g122 g1991 g1992 g1994 '#f '#f)])
-              (case-lambda
-                [(g1996 g1997 g1998 g1999 g2000)
-                 (g175 g1996 g1997 g1998 g1992 g1993 g1999 g2000
-                   g1995)]))])
-         (case-lambda
-           [(g2001 g2002 g2003 g2004 g2005 g2006 g2007 g2008)
-            ((case-lambda
-               [(g2009)
-                (if ((top-level-value 'memv) g2009 '(lexical))
-                    g2002
-                    (if ((top-level-value 'memv) g2009 '(core))
-                        (g2002 g2003 g2004 g2005 g2006 g2007 g2008)
-                        (if ((top-level-value 'memv) g2009 '(lexical-call))
-                            (g176 g2002 g2003 g2004 g2005 g2006 g2007
-                              g2008)
-                            (if ((top-level-value 'memv) g2009 '(constant))
-                                ((top-level-value 'list)
-                                  'quote
-                                  (g198 (g120 g2003 g2006 g2007) '(())))
-                                (if ((top-level-value 'memv)
-                                      g2009
-                                      '(global))
-                                    ((top-level-value 'list)
-                                      'top-level-value
-                                      ((top-level-value 'list)
-                                        'quote
-                                        g2002))
-                                    (if ((top-level-value 'memv)
-                                          g2009
-                                          '(meta-variable))
-                                        (if g2008
-                                            ((top-level-value 'list)
-                                              'top-level-value
-                                              ((top-level-value 'list)
-                                                'quote
-                                                g2002))
-                                            (g34 (g120 g2003 g2006 g2007)))
-                                        (if ((top-level-value 'memv)
-                                              g2009
-                                              '(call))
-                                            (g176
-                                              (g174
-                                                ((top-level-value 'car)
-                                                  g2003)
-                                                g2004 g2005 g2006 g2008)
-                                              g2003 g2004 g2005 g2006 g2007
-                                              g2008)
-                                            (if ((top-level-value 'memv)
-                                                  g2009
-                                                  '(begin-form))
-                                                (g173
-                                                  (g191
-                                                    g2003
-                                                    g2006
-                                                    g2007
-                                                    '#f)
-                                                  g2004 g2005 g2006 g2007
-                                                  g2008)
-                                                (if ((top-level-value
-                                                       'memv)
-                                                      g2009
-                                                      '(local-syntax-form))
-                                                    ((top-level-value
-                                                       'call-with-values)
-                                                      (case-lambda
-                                                        [()
-                                                         (g193 g2002 g2003
-                                                           g2004 g2005
-                                                           g2006 g2007)])
-                                                      (case-lambda
-                                                        [(g2010 g2011 g2012
-                                                          g2013 g2014)
-                                                         (g173 g2010 g2011
-                                                           g2012 g2013
-                                                           g2014 g2008)]))
-                                                    (if ((top-level-value
-                                                           'memv)
-                                                          g2009
-                                                          '(eval-when-form))
-                                                        ((top-level-value
-                                                           'call-with-values)
-                                                          (case-lambda
-                                                            [()
-                                                             (g189
-                                                               g2003
-                                                               g2006
-                                                               g2007)])
-                                                          (case-lambda
-                                                            [(g2015 g2016)
-                                                             (if ((top-level-value
-                                                                    'memq)
-                                                                   'eval
-                                                                   g2015)
-                                                                 (g173
-                                                                   g2016
-                                                                   g2004
-                                                                   g2005
-                                                                   g2006
-                                                                   g2007
-                                                                   g2008)
-                                                                 (g194))]))
-                                                        (if ((top-level-value
-                                                               'memv)
-                                                              g2009
-                                                              '(meta-form))
-                                                            ((top-level-value
-                                                               'syntax-error)
-                                                              (g120
-                                                                g2003
-                                                                g2006
-                                                                g2007)
-                                                              '"invalid context for meta definition")
-                                                            (if ((top-level-value
-                                                                   'memv)
-                                                                  g2009
-                                                                  '(define-form))
-                                                                (begin
-                                                                  (g186
-                                                                    g2003
-                                                                    g2006
-                                                                    g2007)
-                                                                  ((top-level-value
-                                                                     'syntax-error)
-                                                                    (g120
-                                                                      g2003
-                                                                      g2006
-                                                                      g2007)
-                                                                    '"invalid context for definition"))
-                                                                (if ((top-level-value
-                                                                       'memv)
-                                                                      g2009
-                                                                      '(define-syntax-form))
-                                                                    (begin
-                                                                      (g187
-                                                                        g2003
-                                                                        g2006
-                                                                        g2007)
-                                                                      ((top-level-value
-                                                                         'syntax-error)
-                                                                        (g120
-                                                                          g2003
-                                                                          g2006
-                                                                          g2007)
-                                                                        '"invalid context for definition"))
-                                                                    (if ((top-level-value
-                                                                           'memv)
-                                                                          g2009
-                                                                          '($module-form))
-                                                                        ((top-level-value
-                                                                           'call-with-values)
-                                                                          (case-lambda
-                                                                            [()
-                                                                             (g184
-                                                                               g2003
-                                                                               g2006
-                                                                               g2007
-                                                                               g2006)])
-                                                                          (case-lambda
-                                                                            [(g2017
-                                                                              g2018
-                                                                              g2019
-                                                                              g2020)
-                                                                             ((top-level-value
-                                                                                'syntax-error)
-                                                                               g2017
-                                                                               '"invalid context for definition")]))
-                                                                        (if ((top-level-value
-                                                                               'memv)
-                                                                              g2009
-                                                                              '($import-form))
-                                                                            ((top-level-value
-                                                                               'call-with-values)
-                                                                              (case-lambda
-                                                                                [()
-                                                                                 (g185
-                                                                                   g2003
-                                                                                   g2006
-                                                                                   g2007)])
-                                                                              (case-lambda
-                                                                                [(g2021
-                                                                                  g2022
-                                                                                  g2023)
-                                                                                 ((top-level-value
-                                                                                    'syntax-error)
-                                                                                   g2021
-                                                                                   '"invalid context for definition")]))
-                                                                            (if ((top-level-value
-                                                                                   'memv)
-                                                                                  g2009
-                                                                                  '(alias-form))
-                                                                                (begin
-                                                                                  (g190
-                                                                                    g2003
-                                                                                    g2006
-                                                                                    g2007)
-                                                                                  ((top-level-value
-                                                                                     'syntax-error)
-                                                                                    (g120
-                                                                                      g2003
-                                                                                      g2006
-                                                                                      g2007)
-                                                                                    '"invalid context for definition"))
-                                                                                (if ((top-level-value
-                                                                                       'memv)
-                                                                                      g2009
-                                                                                      '(syntax))
-                                                                                    ((top-level-value
-                                                                                       'syntax-error)
-                                                                                      (g120
-                                                                                        g2003
-                                                                                        g2006
-                                                                                        g2007)
-                                                                                      '"reference to pattern variable outside syntax form")
-                                                                                    (if ((top-level-value
-                                                                                           'memv)
-                                                                                          g2009
-                                                                                          '(displaced-lexical))
-                                                                                        (g34 (g120
-                                                                                               g2003
-                                                                                               g2006
-                                                                                               g2007))
-                                                                                        ((top-level-value
-                                                                                           'syntax-error)
-                                                                                          (g120
-                                                                                            g2003
-                                                                                            g2006
-                                                                                            g2007))))))))))))))))))))])
-              g2001)])
-         (case-lambda
-           [(g2024 g2025 g2026 g2027 g2028 g2029 g2030)
-            ((case-lambda
-               [(g2031)
-                ((case-lambda
-                   [(g2032)
-                    (if g2032
-                        (#%apply
-                          (case-lambda
-                            [(g2033 g2034)
-                             ((top-level-value 'cons)
-                               g2024
-                               ((top-level-value 'map)
-                                 (case-lambda
-                                   [(g2035)
-                                    (g174 g2035 g2026 g2027 g2028 g2030)])
-                                 g2034))])
-                          g2032)
-                        ((case-lambda
-                           [(g2036)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2025 g2028 g2029))])
-                          g2031))])
-                  (#%$syntax-dispatch g2031 '(any . each-any)))])
-              g2025)])
-         (case-lambda
-           [(g2037 g2038 g2039 g2040 g2041)
-            ((case-lambda
-               [(g2042)
-                ((case-lambda
-                   [(g2043)
-                    (if (if g2043
-                            (#%apply
-                              (case-lambda
-                                [(g2044 g2045 g2046) (g41 g2045)])
-                              g2043)
-                            '#f)
-                        (#%apply
-                          (case-lambda
-                            [(g2047 g2048 g2049)
-                             ((case-lambda
-                                [(g2050)
-                                 ((case-lambda
-                                    [(g2051)
-                                     ((case-lambda
-                                        [(g2052)
-                                         (if ((top-level-value 'memv)
-                                               g2052
-                                               '(macro!))
-                                             ((case-lambda
-                                                [(g2053 g2054)
-                                                 (g122
-                                                   (g178 (g26 g2051)
-                                                     ((top-level-value
-                                                        'list)
-                                                       '#(syntax-object
-                                                          set!
-                                                          ((top)
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage
-                                                              #(id val)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(t)
-                                                              #(("m" top))
-                                                              #("i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(b)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(n)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage
-                                                              #(_ id val)
-                                                              #((top) (top)
-                                                                (top))
-                                                              #("i" "i"
-                                                                "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage
-                                                              #(e r w ae
-                                                                rib)
-                                                              #((top) (top)
-                                                                (top) (top)
-                                                                (top))
-                                                              #("i" "i" "i"
-                                                                "i" "i"))
-                                                            #(ribcage
-                                                              (lambda-var-list
-                                                               gen-var
-                                                               strip strip*
-                                                               strip-annotation
-                                                               ellipsis?
-                                                               chi-void
-                                                               chi-local-syntax
-                                                               chi-lambda-clause
-                                                               parse-begin
-                                                               parse-alias
-                                                               parse-eval-when
-                                                               parse-meta
-                                                               parse-define-syntax
-                                                               parse-define
-                                                               parse-import
-                                                               parse-module
-                                                               do-import!
-                                                               lookup-import-label
-                                                               import-mark-delta
-                                                               chi-internal
-                                                               chi-body
-                                                               chi-macro
-                                                               chi-set!
-                                                               chi-application
-                                                               chi-expr chi
-                                                               chi-sequence
-                                                               chi-meta-frob
-                                                               chi-frobs
-                                                               ct-eval/residualize3
-                                                               ct-eval/residualize2
-                                                               rt-eval/residualize
-                                                               initial-mode-set
-                                                               update-mode-set
-                                                               do-top-import
-                                                               vfor-each
-                                                               vmap
-                                                               chi-external
-                                                               check-defined-ids
-                                                               check-module-exports
-                                                               id-set-diff
-                                                               chi-top-module
-                                                               set-frob-meta?!
-                                                               set-frob-e!
-                                                               frob-meta?
-                                                               frob-e frob?
-                                                               make-frob
-                                                               create-module-binding
-                                                               set-module-binding-exported!
-                                                               set-module-binding-val!
-                                                               set-module-binding-imps!
-                                                               set-module-binding-label!
-                                                               set-module-binding-id!
-                                                               set-module-binding-type!
-                                                               module-binding-exported
-                                                               module-binding-val
-                                                               module-binding-imps
-                                                               module-binding-label
-                                                               module-binding-id
-                                                               module-binding-type
-                                                               module-binding?
-                                                               make-module-binding
-                                                               make-resolved-interface
-                                                               make-unresolved-interface
-                                                               set-interface-token!
-                                                               set-interface-exports!
-                                                               set-interface-marks!
-                                                               interface-token
-                                                               interface-exports
-                                                               interface-marks
-                                                               interface?
-                                                               make-interface
-                                                               flatten-exports
-                                                               chi-top
-                                                               chi-top-sequence
-                                                               chi-top*
-                                                               syntax-type
-                                                               chi-when-list
-                                                               source-wrap
-                                                               wrap
-                                                               bound-id-member?
-                                                               invalid-ids-error
-                                                               distinct-bound-ids?
-                                                               valid-bound-ids?
-                                                               bound-id=?
-                                                               help-bound-id=?
-                                                               literal-id=?
-                                                               free-id=?
-                                                               id-var-name
-                                                               id-var-name-loc
-                                                               id-var-name&marks
-                                                               id-var-name-loc&marks
-                                                               top-id-free-var-name
-                                                               top-id-bound-var-name
-                                                               anon
-                                                               diff-marks
-                                                               same-marks?
-                                                               join-subst
-                                                               join-marks
-                                                               join-wraps
-                                                               smart-append
-                                                               resolved-id-var-name
-                                                               id->resolved-id
-                                                               make-resolved-id
-                                                               make-binding-wrap
-                                                               store-import-binding
-                                                               lookup-import-binding-name
-                                                               extend-ribcage-subst!
-                                                               extend-ribcage-barrier-help!
-                                                               extend-ribcage-barrier!
-                                                               import-extend-ribcage!
-                                                               extend-ribcage!
-                                                               make-empty-ribcage
-                                                               barrier-marker
-                                                               new-mark
-                                                               anti-mark
-                                                               the-anti-mark
-                                                               set-env-wrap!
-                                                               set-env-top-ribcage!
-                                                               env-wrap
-                                                               env-top-ribcage
-                                                               env?
-                                                               make-env
-                                                               set-import-interface-new-marks!
-                                                               set-import-interface-interface!
-                                                               import-interface-new-marks
-                                                               import-interface-interface
-                                                               import-interface?
-                                                               make-import-interface
-                                                               set-top-ribcage-mutable?!
-                                                               set-top-ribcage-key!
-                                                               top-ribcage-mutable?
-                                                               top-ribcage-key
-                                                               top-ribcage?
-                                                               make-top-ribcage
-                                                               set-ribcage-labels!
-                                                               set-ribcage-marks!
-                                                               set-ribcage-symnames!
-                                                               ribcage-labels
-                                                               ribcage-marks
-                                                               ribcage-symnames
-                                                               ribcage?
-                                                               make-ribcage
-                                                               gen-labels
-                                                               label?
-                                                               gen-label
-                                                               set-indirect-label!
-                                                               get-indirect-label
-                                                               indirect-label?
-                                                               gen-indirect-label
-                                                               anon
-                                                               only-top-marked?
-                                                               top-marked?
-                                                               top-wrap
-                                                               empty-wrap
-                                                               wrap-subst
-                                                               wrap-marks
-                                                               make-wrap
-                                                               id-sym-name&marks
-                                                               id-subst
-                                                               id-marks
-                                                               id-sym-name
-                                                               id?
-                                                               nonsymbol-id?
-                                                               global-extend
-                                                               defer-or-eval-transformer
-                                                               make-transformer-binding
-                                                               lookup
-                                                               lookup*
-                                                               displaced-lexical-error
-                                                               displaced-lexical?
-                                                               extend-var-env*
-                                                               extend-env*
-                                                               extend-env
-                                                               null-env
-                                                               binding?
-                                                               set-binding-value!
-                                                               set-binding-type!
-                                                               binding-value
-                                                               binding-type
-                                                               make-binding
-                                                               sanitize-binding
-                                                               arg-check
-                                                               no-source
-                                                               unannotate
-                                                               self-evaluating?
-                                                               lexical-var?
-                                                               build-lexical-var
-                                                               build-top-module
-                                                               build-body
-                                                               build-letrec
-                                                               build-sequence
-                                                               build-data
-                                                               build-primref
-                                                               built-lambda?
-                                                               build-lambda
-                                                               build-revisit-only
-                                                               build-visit-only
-                                                               build-cte-install
-                                                               build-global-definition
-                                                               build-global-assignment
-                                                               build-global-reference
-                                                               build-lexical-assignment
-                                                               build-lexical-reference
-                                                               build-conditional
-                                                               build-application
-                                                               generate-id
-                                                               put-import-binding
-                                                               get-import-binding
-                                                               read-only-binding?
-                                                               put-global-definition-hook
-                                                               get-global-definition-hook
-                                                               put-cte-hook
-                                                               gensym-hook
-                                                               error-hook
-                                                               define-top-level-value-hook
-                                                               local-eval-hook
-                                                               top-level-eval-hook
-                                                               annotation?
-                                                               set-syntax-object-wrap!
-                                                               set-syntax-object-expression!
-                                                               syntax-object-wrap
-                                                               syntax-object-expression
-                                                               syntax-object?
-                                                               make-syntax-object
-                                                               noexpand
-                                                               let-values
-                                                               define-structure
-                                                               unless when)
-                                                              ((top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               ("m" top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top)
-                                                               ("m" top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top))
-                                                              ("i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       g2053
-                                                       g2054)
-                                                     g2038 '(()) '#f g2041)
-                                                   g2038 '(()) '#f g2041)])
-                                               (g119 g2048 g2039)
-                                               (g119 g2049 g2039))
-                                             ((top-level-value 'values)
-                                               'core
-                                               (case-lambda
-                                                 [(g2055 g2056 g2057 g2058
-                                                   g2059 g2060)
-                                                  ((case-lambda
-                                                     [(g2061 g2062)
-                                                      ((case-lambda
-                                                         [(g2063)
-                                                          ((case-lambda
-                                                             [(g2064)
-                                                              (if ((top-level-value
-                                                                     'memv)
-                                                                    g2064
-                                                                    '(lexical))
-                                                                  ((top-level-value
-                                                                     'list)
-                                                                    'set!
-                                                                    (g26 g2063)
-                                                                    g2061)
-                                                                  (if ((top-level-value
-                                                                         'memv)
-                                                                        g2064
-                                                                        '(global))
-                                                                      ((case-lambda
-                                                                         [(g2065)
-                                                                          (begin
-                                                                            (if (g15 g2062)
-                                                                                ((top-level-value
-                                                                                   'syntax-error)
-                                                                                  (g120
-                                                                                    g2055
-                                                                                    g2058
-                                                                                    g2059)
-                                                                                  '"invalid assignment to read-only variable")
-                                                                                (#%void))
-                                                                            ((top-level-value
-                                                                               'list)
-                                                                              'set-top-level-value!
-                                                                              ((top-level-value
-                                                                                 'list)
-                                                                                'quote
-                                                                                g2065)
-                                                                              g2061))])
-                                                                        (g26 g2063))
-                                                                      (if ((top-level-value
-                                                                             'memv)
-                                                                            g2064
-                                                                            '(meta-variable))
-                                                                          (if g2060
-                                                                              ((top-level-value
-                                                                                 'list)
-                                                                                'set-top-level-value!
-                                                                                ((top-level-value
-                                                                                   'list)
-                                                                                  'quote
-                                                                                  (g26 g2063))
-                                                                                g2061)
-                                                                              (g34 (g119
-                                                                                     g2048
-                                                                                     g2058)))
-                                                                          (if ((top-level-value
-                                                                                 'memv)
-                                                                                g2064
-                                                                                '(displaced-lexical))
-                                                                              (g34 (g119
-                                                                                     g2048
-                                                                                     g2058))
-                                                                              ((top-level-value
-                                                                                 'syntax-error)
-                                                                                (g120
-                                                                                  g2055
-                                                                                  g2058
-                                                                                  g2059))))))])
-                                                            (g25 g2063))])
-                                                        (g36 g2062
-                                                             g2056))])
-                                                    (g174 g2049 g2056 g2057
-                                                      g2058 g2060)
-                                                    (g110 g2048 g2058))])
-                                               g2037 g2039 g2040))])
-                                       (g25 g2051))])
-                                   (g36 g2050 g2038))])
-                               (g110 g2048 g2039))])
-                          g2043)
-                        ((case-lambda
-                           [(g2066)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2037 g2039 g2040))])
-                          g2042))])
-                  (#%$syntax-dispatch g2042 '(any any any)))])
-              g2037)])
-         (case-lambda
-           [(g2067 g2068 g2069 g2070 g2071 g2072)
-            ((case-lambda
-               [(g2073)
-                ((case-lambda
-                   [(g2074)
-                    (begin
-                      (set! g2073 g2074)
-                      (g2073
-                        ((case-lambda
-                           [(g2075)
-                            (if ((top-level-value 'procedure?) g2075)
-                                (g2075
-                                  (case-lambda
-                                    [(g2076)
-                                     (begin
-                                       (if ((top-level-value 'not)
-                                             ((top-level-value
-                                                'identifier?)
-                                               g2076))
-                                           ((top-level-value 'syntax-error)
-                                             g2076
-                                             '"environment argument is not an identifier")
-                                           (#%void))
-                                       (g36 (g110 g2076 '(())) g2069))]))
-                                g2075)])
-                          (g2067 (g120 g2068 (g84 g2070) g2071)))
-                        ((top-level-value 'string) '#\m)))])
-                  (case-lambda
-                    [(g2077 g2078)
-                     (if ((top-level-value 'pair?) g2077)
-                         ((top-level-value 'cons)
-                           (g2073 ((top-level-value 'car) g2077) g2078)
-                           (g2073 ((top-level-value 'cdr) g2077) g2078))
-                         (if (g2 g2077)
-                             ((case-lambda
-                                [(g2079)
-                                 ((case-lambda
-                                    [(g2080 g2081)
-                                     (g1 (g3 g2077)
-                                         (if (if ((top-level-value 'pair?)
-                                                   g2080)
-                                                 ((top-level-value 'eq?)
-                                                   ((top-level-value 'car)
-                                                     g2080)
-                                                   '#f)
-                                                 '#f)
-                                             (g45 ((top-level-value 'cdr)
-                                                    g2080)
-                                                  ((top-level-value 'cdr)
-                                                    g2081))
-                                             (g45 ((top-level-value 'cons)
-                                                    g2078
-                                                    g2080)
-                                                  (if g2072
-                                                      ((top-level-value
-                                                         'cons)
-                                                        g2072
-                                                        ((top-level-value
-                                                           'cons)
-                                                          'shift
-                                                          g2081))
-                                                      ((top-level-value
-                                                         'cons)
-                                                        'shift
-                                                        g2081)))))])
-                                   (g46 g2079)
-                                   (g47 g2079))])
-                               (g4 g2077))
-                             (if ((top-level-value 'vector?) g2077)
-                                 ((case-lambda
-                                    [(g2082)
-                                     ((case-lambda
-                                        [(g2083)
-                                         ((case-lambda
-                                            [()
-                                             (((case-lambda
-                                                 [(g2084)
-                                                  ((case-lambda
-                                                     [(g2085)
-                                                      (begin
-                                                        (set! g2084 g2085)
-                                                        g2084)])
-                                                    (case-lambda
-                                                      [(g2086)
-                                                       (if ((top-level-value
-                                                              'fx=)
-                                                             g2086
-                                                             g2082)
-                                                           g2083
-                                                           (begin
-                                                             ((top-level-value
-                                                                'vector-set!)
-                                                               g2083
-                                                               g2086
-                                                               (g2073
-                                                                 ((top-level-value
-                                                                    'vector-ref)
-                                                                   g2077
-                                                                   g2086)
-                                                                 g2078))
-                                                             (g2084
-                                                               ((top-level-value
-                                                                  'fx+)
-                                                                 g2086
-                                                                 '1))))]))])
-                                                (void))
-                                               '0)]))])
-                                       ((top-level-value 'make-vector)
-                                         g2082))])
-                                   ((top-level-value 'vector-length)
-                                     g2077))
-                                 (if ((top-level-value 'symbol?) g2077)
-                                     ((top-level-value 'syntax-error)
-                                       (g120 g2068 g2070 g2071)
-                                       '"encountered raw symbol "
-                                       ((top-level-value 'symbol->string)
-                                         g2077)
-                                       '" in output of macro")
-                                     g2077))))]))])
-              (void))])
-         (case-lambda
-           [(g2087 g2088 g2089 g2090 g2091 g2092)
-            ((case-lambda
-               [(g2093)
-                ((case-lambda
-                   [(g2094)
-                    ((case-lambda
-                       [(g2095)
-                        ((case-lambda
-                           [()
-                            ((top-level-value 'call-with-values)
-                              (case-lambda
-                                [()
-                                 (g180 g2093 g2088 g2095 g2089 g2090
-                                   g2092)])
-                              (case-lambda
-                                [(g2096 g2097 g2098 g2099 g2100 g2101
-                                  g2102)
-                                 (begin
-                                   (if ((top-level-value 'null?) g2098)
-                                       ((top-level-value 'syntax-error)
-                                         g2088
-                                         '"no expressions in body")
-                                       (#%void))
-                                   (g22 '#f
-                                        ((top-level-value 'reverse) g2100)
-                                        (g171
-                                          ((top-level-value 'reverse)
-                                            g2101)
-                                          g2096
-                                          g2097
-                                          g2092)
-                                        (g20 '#f
-                                             (g171
-                                               ((top-level-value 'append)
-                                                 g2102
-                                                 g2098)
-                                               g2096
-                                               g2097
-                                               g2092))))]))]))])
-                      ((top-level-value 'map)
-                        (case-lambda
-                          [(g2103) (g152 (g119 g2103 g2094) '#f)])
-                        g2087))])
-                  (g45 (g46 g2091)
-                       ((top-level-value 'cons) g2093 (g47 g2091))))])
-              (g58 '() '() '()))])
-         (case-lambda
-           [(g2104 g2105 g2106 g2107 g2108 g2109)
-            ((case-lambda
-               [(g2110)
-                ((case-lambda
-                   [(g2111)
-                    (begin
-                      (set! g2110 g2111)
-                      (((case-lambda
-                          [(g2112)
-                           ((case-lambda
-                              [(g2113) (begin (set! g2112 g2113) g2112)])
-                             (case-lambda
-                               [(g2114 g2115 g2116 g2117 g2118 g2119 g2120
-                                 g2121)
-                                (if ((top-level-value 'null?) g2114)
-                                    (g2110 g2115 g2116 g2114 g2117 g2118
-                                      g2119 g2120)
-                                    ((case-lambda
-                                       [(g2122)
-                                        ((case-lambda
-                                           [(g2123)
-                                            ((case-lambda
-                                               [(g2124)
-                                                ((case-lambda
-                                                   [()
-                                                    ((top-level-value
-                                                       'call-with-values)
-                                                      (case-lambda
-                                                        [()
-                                                         (g122 g2123 g2115
-                                                           '(()) '#f
-                                                           g2104)])
-                                                      (case-lambda
-                                                        [(g2125 g2126 g2127
-                                                          g2128 g2129)
-                                                         ((case-lambda
-                                                            [(g2130)
-                                                             (if ((top-level-value
-                                                                    'memv)
-                                                                   g2130
-                                                                   '(define-form))
-                                                                 ((top-level-value
-                                                                    'call-with-values)
-                                                                   (case-lambda
-                                                                     [()
-                                                                      (g186
-                                                                        g2127
-                                                                        g2128
-                                                                        g2129)])
-                                                                   (case-lambda
-                                                                     [(g2131
-                                                                       g2132
-                                                                       g2133)
-                                                                      ((case-lambda
-                                                                         [(g2134
-                                                                           g2135)
-                                                                          (if g2124
-                                                                              ((case-lambda
-                                                                                 [(g2136)
-                                                                                  (begin
-                                                                                    (g86 g2104
-                                                                                         g2134
-                                                                                         g2135)
-                                                                                    ((case-lambda
-                                                                                       [(g2137)
-                                                                                        (begin
-                                                                                          (g10 g2136
-                                                                                               (g8 (g174
-                                                                                                     g2132
-                                                                                                     g2137
-                                                                                                     g2137
-                                                                                                     g2133
-                                                                                                     '#t)))
-                                                                                          (g2112
-                                                                                            ((top-level-value
-                                                                                               'cdr)
-                                                                                              g2114)
-                                                                                            g2115
-                                                                                            g2137
-                                                                                            ((top-level-value
-                                                                                               'cons)
-                                                                                              g2134
-                                                                                              g2117)
-                                                                                            g2118
-                                                                                            g2119
-                                                                                            g2120
-                                                                                            '#f))])
-                                                                                      (g30 g2135
-                                                                                           ((top-level-value
-                                                                                              'cons)
-                                                                                             'meta-variable
-                                                                                             g2136)
-                                                                                           g2116)))])
-                                                                                (g18 ((case-lambda
-                                                                                        [(g2138)
-                                                                                         ((case-lambda
-                                                                                            [(g2139)
-                                                                                             (if (g7 g2139)
-                                                                                                 ((top-level-value
-                                                                                                    'annotation-expression)
-                                                                                                   g2139)
-                                                                                                 g2139)])
-                                                                                           (if (g2 g2138)
-                                                                                               (g3 g2138)
-                                                                                               g2138))])
-                                                                                       g2134)))
-                                                                              ((case-lambda
-                                                                                 [(g2140)
-                                                                                  (begin
-                                                                                    (g86 g2104
-                                                                                         g2134
-                                                                                         g2135)
-                                                                                    (g2112
-                                                                                      ((top-level-value
-                                                                                         'cdr)
-                                                                                        g2114)
-                                                                                      (g30 g2135
-                                                                                           ((top-level-value
-                                                                                              'cons)
-                                                                                             'lexical
-                                                                                             g2140)
-                                                                                           g2115)
-                                                                                      g2116
-                                                                                      ((top-level-value
-                                                                                         'cons)
-                                                                                        g2134
-                                                                                        g2117)
-                                                                                      ((top-level-value
-                                                                                         'cons)
-                                                                                        g2140
-                                                                                        g2118)
-                                                                                      ((top-level-value
-                                                                                         'cons)
-                                                                                        (g152
-                                                                                          (g119
-                                                                                            g2132
-                                                                                            g2133)
-                                                                                          g2124)
-                                                                                        g2119)
-                                                                                      g2120
-                                                                                      '#f))])
-                                                                                (g199
-                                                                                  g2134)))])
-                                                                        (g119
-                                                                          g2131
-                                                                          g2133)
-                                                                        (g55))]))
-                                                                 (if ((top-level-value
-                                                                        'memv)
-                                                                       g2130
-                                                                       '(define-syntax-form))
-                                                                     ((top-level-value
-                                                                        'call-with-values)
-                                                                       (case-lambda
-                                                                         [()
-                                                                          (g187
-                                                                            g2127
-                                                                            g2128
-                                                                            g2129)])
-                                                                       (case-lambda
-                                                                         [(g2141
-                                                                           g2142
-                                                                           g2143)
-                                                                          ((case-lambda
-                                                                             [(g2144
-                                                                               g2145
-                                                                               g2146)
-                                                                              (begin
-                                                                                (g86 g2104
-                                                                                     g2144
-                                                                                     g2145)
-                                                                                ((case-lambda
-                                                                                   [(g2147)
-                                                                                    (g2112
-                                                                                      ((top-level-value
-                                                                                         'cdr)
-                                                                                        g2114)
-                                                                                      (g30 g2145
-                                                                                           g2147
-                                                                                           g2115)
-                                                                                      (g30 g2145
-                                                                                           g2147
-                                                                                           g2116)
-                                                                                      ((top-level-value
-                                                                                         'cons)
-                                                                                        g2144
-                                                                                        g2117)
-                                                                                      g2118
-                                                                                      g2119
-                                                                                      g2120
-                                                                                      '#f)])
-                                                                                  (g38 g9
-                                                                                       g2146)))])
-                                                                            (g119
-                                                                              g2141
-                                                                              g2143)
-                                                                            (g55)
-                                                                            (g174
-                                                                              g2142
-                                                                              g2116
-                                                                              g2116
-                                                                              g2143
-                                                                              '#t))]))
-                                                                     (if ((top-level-value
-                                                                            'memv)
-                                                                           g2130
-                                                                           '($module-form))
-                                                                         ((case-lambda
-                                                                            [(g2148)
-                                                                             ((case-lambda
-                                                                                [(g2149)
-                                                                                 ((case-lambda
-                                                                                    [()
-                                                                                     ((top-level-value
-                                                                                        'call-with-values)
-                                                                                       (case-lambda
-                                                                                         [()
-                                                                                          (g184
-                                                                                            g2127
-                                                                                            g2128
-                                                                                            g2129
-                                                                                            g2149)])
-                                                                                       (case-lambda
-                                                                                         [(g2150
-                                                                                           g2151
-                                                                                           g2152
-                                                                                           g2153)
-                                                                                          ((top-level-value
-                                                                                             'call-with-values)
-                                                                                            (case-lambda
-                                                                                              [()
-                                                                                               (g180
-                                                                                                 g2148
-                                                                                                 g2150
-                                                                                                 ((top-level-value
-                                                                                                    'map)
-                                                                                                   (case-lambda
-                                                                                                     [(g2154)
-                                                                                                      (g152
-                                                                                                        g2154
-                                                                                                        g2124)])
-                                                                                                   g2153)
-                                                                                                 g2115
-                                                                                                 g2116
-                                                                                                 g2109)])
-                                                                                            (case-lambda
-                                                                                              [(g2155
-                                                                                                g2156
-                                                                                                g2157
-                                                                                                g2158
-                                                                                                g2159
-                                                                                                g2160
-                                                                                                g2161)
-                                                                                               (begin
-                                                                                                 (g160
-                                                                                                   g2105
-                                                                                                   (g126
-                                                                                                     g2152)
-                                                                                                   g2158)
-                                                                                                 ((case-lambda
-                                                                                                    [(g2162
-                                                                                                      g2163
-                                                                                                      g2164
-                                                                                                      g2165
-                                                                                                      g2166)
-                                                                                                     (begin
-                                                                                                       (g86 g2104
-                                                                                                            g2151
-                                                                                                            g2166)
-                                                                                                       ((case-lambda
-                                                                                                          [(g2167)
-                                                                                                           (g2112
-                                                                                                             ((top-level-value
-                                                                                                                'cdr)
-                                                                                                               g2114)
-                                                                                                             (g30 g2166
-                                                                                                                  g2167
-                                                                                                                  g2155)
-                                                                                                             (g30 g2166
-                                                                                                                  g2167
-                                                                                                                  g2156)
-                                                                                                             ((top-level-value
-                                                                                                                'cons)
-                                                                                                               g2151
-                                                                                                               g2117)
-                                                                                                             g2163
-                                                                                                             g2164
-                                                                                                             g2165
-                                                                                                             '#f)])
-                                                                                                         ((top-level-value
-                                                                                                            'cons)
-                                                                                                           '$module
-                                                                                                           g2162)))])
-                                                                                                   (g136
-                                                                                                     g2151
-                                                                                                     g2152
-                                                                                                     '#f)
-                                                                                                   ((top-level-value
-                                                                                                      'append)
-                                                                                                     g2159
-                                                                                                     g2118)
-                                                                                                   ((top-level-value
-                                                                                                      'append)
-                                                                                                     g2160
-                                                                                                     g2119)
-                                                                                                   ((top-level-value
-                                                                                                      'append)
-                                                                                                     g2120
-                                                                                                     g2161
-                                                                                                     g2157)
-                                                                                                   (g55)))]))]))]))])
-                                                                               (g45 (g46 g2128)
-                                                                                    ((top-level-value
-                                                                                       'cons)
-                                                                                      g2148
-                                                                                      (g47 g2128))))])
-                                                                           (g58 '()
-                                                                                '()
-                                                                                '()))
-                                                                         (if ((top-level-value
-                                                                                'memv)
-                                                                               g2130
-                                                                               '($import-form))
-                                                                             ((top-level-value
-                                                                                'call-with-values)
-                                                                               (case-lambda
-                                                                                 [()
-                                                                                  (g185
-                                                                                    g2127
-                                                                                    g2128
-                                                                                    g2129)])
-                                                                               (case-lambda
-                                                                                 [(g2168
-                                                                                   g2169
-                                                                                   g2170)
-                                                                                  ((case-lambda
-                                                                                     [(g2171)
-                                                                                      ((case-lambda
-                                                                                         [(g2172)
-                                                                                          ((case-lambda
-                                                                                             [(g2173)
-                                                                                              (if ((top-level-value
-                                                                                                     'memv)
-                                                                                                    g2173
-                                                                                                    '($module))
-                                                                                                  ((case-lambda
-                                                                                                     [(g2174)
-                                                                                                      ((case-lambda
-                                                                                                         [(g2175)
-                                                                                                          ((case-lambda
-                                                                                                             [()
-                                                                                                              (begin
-                                                                                                                (if g2169
-                                                                                                                    (g88 g2104
-                                                                                                                         g2170)
-                                                                                                                    (#%void))
-                                                                                                                (g183
-                                                                                                                  g2175
-                                                                                                                  g2104)
-                                                                                                                (g2112
-                                                                                                                  ((top-level-value
-                                                                                                                     'cdr)
-                                                                                                                    g2114)
-                                                                                                                  g2115
-                                                                                                                  g2116
-                                                                                                                  ((top-level-value
-                                                                                                                     'cons)
-                                                                                                                    g2175
-                                                                                                                    g2117)
-                                                                                                                  g2118
-                                                                                                                  g2119
-                                                                                                                  g2120
-                                                                                                                  '#f))]))])
-                                                                                                        (g72 g2174
-                                                                                                             (g181
-                                                                                                               g2170
-                                                                                                               g2174)))])
-                                                                                                    (g26 g2172))
-                                                                                                  (if ((top-level-value
-                                                                                                         'memv)
-                                                                                                        g2173
-                                                                                                        '(displaced-lexical))
-                                                                                                      (g34 g2170)
-                                                                                                      ((top-level-value
-                                                                                                         'syntax-error)
-                                                                                                        g2170
-                                                                                                        '"unknown module")))])
-                                                                                            (g25 g2172))])
-                                                                                        (g36 g2171
-                                                                                             g2115))])
-                                                                                    (g110
-                                                                                      g2170
-                                                                                      '(())))]))
-                                                                             (if ((top-level-value
-                                                                                    'memv)
-                                                                                   g2130
-                                                                                   '(alias-form))
-                                                                                 ((top-level-value
-                                                                                    'call-with-values)
-                                                                                   (case-lambda
-                                                                                     [()
-                                                                                      (g190
-                                                                                        g2127
-                                                                                        g2128
-                                                                                        g2129)])
-                                                                                   (case-lambda
-                                                                                     [(g2176
-                                                                                       g2177)
-                                                                                      ((case-lambda
-                                                                                         [(g2178)
-                                                                                          (begin
-                                                                                            (g86 g2104
-                                                                                                 g2178
-                                                                                                 (g109
-                                                                                                   g2177
-                                                                                                   g2128))
-                                                                                            (g2112
-                                                                                              ((top-level-value
-                                                                                                 'cdr)
-                                                                                                g2114)
-                                                                                              g2115
-                                                                                              g2116
-                                                                                              ((top-level-value
-                                                                                                 'cons)
-                                                                                                g2178
-                                                                                                g2117)
-                                                                                              g2118
-                                                                                              g2119
-                                                                                              g2120
-                                                                                              '#f))])
-                                                                                        (g119
-                                                                                          g2176
-                                                                                          g2128))]))
-                                                                                 (if ((top-level-value
-                                                                                        'memv)
-                                                                                       g2130
-                                                                                       '(begin-form))
-                                                                                     (g2112
-                                                                                       (((case-lambda
-                                                                                           [(g2179)
-                                                                                            ((case-lambda
-                                                                                               [(g2180)
-                                                                                                (begin
-                                                                                                  (set! g2179
-                                                                                                    g2180)
-                                                                                                  g2179)])
-                                                                                              (case-lambda
-                                                                                                [(g2181)
-                                                                                                 (if ((top-level-value
-                                                                                                        'null?)
-                                                                                                       g2181)
-                                                                                                     ((top-level-value
-                                                                                                        'cdr)
-                                                                                                       g2114)
-                                                                                                     ((top-level-value
-                                                                                                        'cons)
-                                                                                                       (g152
-                                                                                                         (g119
-                                                                                                           ((top-level-value
-                                                                                                              'car)
-                                                                                                             g2181)
-                                                                                                           g2128)
-                                                                                                         g2124)
-                                                                                                       (g2179
-                                                                                                         ((top-level-value
-                                                                                                            'cdr)
-                                                                                                           g2181))))]))])
-                                                                                          (void))
-                                                                                         (g191
-                                                                                           g2127
-                                                                                           g2128
-                                                                                           g2129
-                                                                                           '#t))
-                                                                                       g2115
-                                                                                       g2116
-                                                                                       g2117
-                                                                                       g2118
-                                                                                       g2119
-                                                                                       g2120
-                                                                                       '#f)
-                                                                                     (if ((top-level-value
-                                                                                            'memv)
-                                                                                           g2130
-                                                                                           '(eval-when-form))
-                                                                                         ((top-level-value
-                                                                                            'call-with-values)
-                                                                                           (case-lambda
-                                                                                             [()
-                                                                                              (g189
-                                                                                                g2127
-                                                                                                g2128
-                                                                                                g2129)])
-                                                                                           (case-lambda
-                                                                                             [(g2182
-                                                                                               g2183)
-                                                                                              (g2112
-                                                                                                (if ((top-level-value
-                                                                                                       'memq)
-                                                                                                      'eval
-                                                                                                      g2182)
-                                                                                                    (((case-lambda
-                                                                                                        [(g2184)
-                                                                                                         ((case-lambda
-                                                                                                            [(g2185)
-                                                                                                             (begin
-                                                                                                               (set! g2184
-                                                                                                                 g2185)
-                                                                                                               g2184)])
-                                                                                                           (case-lambda
-                                                                                                             [(g2186)
-                                                                                                              (if ((top-level-value
-                                                                                                                     'null?)
-                                                                                                                    g2186)
-                                                                                                                  ((top-level-value
-                                                                                                                     'cdr)
-                                                                                                                    g2114)
-                                                                                                                  ((top-level-value
-                                                                                                                     'cons)
-                                                                                                                    (g152
-                                                                                                                      (g119
-                                                                                                                        ((top-level-value
-                                                                                                                           'car)
-                                                                                                                          g2186)
-                                                                                                                        g2128)
-                                                                                                                      g2124)
-                                                                                                                    (g2184
-                                                                                                                      ((top-level-value
-                                                                                                                         'cdr)
-                                                                                                                        g2186))))]))])
-                                                                                                       (void))
-                                                                                                      g2183)
-                                                                                                    ((top-level-value
-                                                                                                       'cdr)
-                                                                                                      g2114))
-                                                                                                g2115
-                                                                                                g2116
-                                                                                                g2117
-                                                                                                g2118
-                                                                                                g2119
-                                                                                                g2120
-                                                                                                '#f)]))
-                                                                                         (if ((top-level-value
-                                                                                                'memv)
-                                                                                               g2130
-                                                                                               '(meta-form))
-                                                                                             (g2112
-                                                                                               ((top-level-value
-                                                                                                  'cons)
-                                                                                                 (g152
-                                                                                                   (g119
-                                                                                                     (g188
-                                                                                                       g2127
-                                                                                                       g2128
-                                                                                                       g2129)
-                                                                                                     g2128)
-                                                                                                   '#t)
-                                                                                                 ((top-level-value
-                                                                                                    'cdr)
-                                                                                                   g2114))
-                                                                                               g2115
-                                                                                               g2116
-                                                                                               g2117
-                                                                                               g2118
-                                                                                               g2119
-                                                                                               g2120
-                                                                                               '#t)
-                                                                                             (if ((top-level-value
-                                                                                                    'memv)
-                                                                                                   g2130
-                                                                                                   '(local-syntax-form))
-                                                                                                 ((top-level-value
-                                                                                                    'call-with-values)
-                                                                                                   (case-lambda
-                                                                                                     [()
-                                                                                                      (g193
-                                                                                                        g2126
-                                                                                                        g2127
-                                                                                                        g2115
-                                                                                                        g2116
-                                                                                                        g2128
-                                                                                                        g2129)])
-                                                                                                   (case-lambda
-                                                                                                     [(g2187
-                                                                                                       g2188
-                                                                                                       g2189
-                                                                                                       g2190
-                                                                                                       g2191)
-                                                                                                      (g2112
-                                                                                                        (((case-lambda
-                                                                                                            [(g2192)
-                                                                                                             ((case-lambda
-                                                                                                                [(g2193)
-                                                                                                                 (begin
-                                                                                                                   (set! g2192
-                                                                                                                     g2193)
-                                                                                                                   g2192)])
-                                                                                                               (case-lambda
-                                                                                                                 [(g2194)
-                                                                                                                  (if ((top-level-value
-                                                                                                                         'null?)
-                                                                                                                        g2194)
-                                                                                                                      ((top-level-value
-                                                                                                                         'cdr)
-                                                                                                                        g2114)
-                                                                                                                      ((top-level-value
-                                                                                                                         'cons)
-                                                                                                                        (g152
-                                                                                                                          (g119
-                                                                                                                            ((top-level-value
-                                                                                                                               'car)
-                                                                                                                              g2194)
-                                                                                                                            g2190)
-                                                                                                                          g2124)
-                                                                                                                        (g2192
-                                                                                                                          ((top-level-value
-                                                                                                                             'cdr)
-                                                                                                                            g2194))))]))])
-                                                                                                           (void))
-                                                                                                          g2187)
-                                                                                                        g2188
-                                                                                                        g2189
-                                                                                                        g2117
-                                                                                                        g2118
-                                                                                                        g2119
-                                                                                                        g2120
-                                                                                                        '#f)]))
-                                                                                                 (begin
-                                                                                                   (if g2121
-                                                                                                       ((top-level-value
-                                                                                                          'syntax-error)
-                                                                                                         (g120
-                                                                                                           g2127
-                                                                                                           g2128
-                                                                                                           g2129)
-                                                                                                         '"invalid meta definition")
-                                                                                                       (#%void))
-                                                                                                   (((case-lambda
-                                                                                                       [(g2195)
-                                                                                                        ((case-lambda
-                                                                                                           [(g2196)
-                                                                                                            (begin
-                                                                                                              (set! g2195
-                                                                                                                g2196)
-                                                                                                              g2195)])
-                                                                                                          (case-lambda
-                                                                                                            [(g2197)
-                                                                                                             (if ((case-lambda
-                                                                                                                    [(g2198)
-                                                                                                                     (if g2198
-                                                                                                                         g2198
-                                                                                                                         ((top-level-value
-                                                                                                                            'not)
-                                                                                                                           (g155
-                                                                                                                             ((top-level-value
-                                                                                                                                'car)
-                                                                                                                               g2197))))])
-                                                                                                                   ((top-level-value
-                                                                                                                      'null?)
-                                                                                                                     g2197))
-                                                                                                                 (g2110
-                                                                                                                   g2115
-                                                                                                                   g2116
-                                                                                                                   g2197
-                                                                                                                   g2117
-                                                                                                                   g2118
-                                                                                                                   g2119
-                                                                                                                   g2120)
-                                                                                                                 (begin
-                                                                                                                   (g8 (g172
-                                                                                                                         ((top-level-value
-                                                                                                                            'car)
-                                                                                                                           g2197)
-                                                                                                                         g2116))
-                                                                                                                   (g2195
-                                                                                                                     ((top-level-value
-                                                                                                                        'cdr)
-                                                                                                                       g2197))))]))])
-                                                                                                      (void))
-                                                                                                     ((top-level-value
-                                                                                                        'cons)
-                                                                                                       (g152
-                                                                                                         (g120
-                                                                                                           g2127
-                                                                                                           g2128
-                                                                                                           g2129)
-                                                                                                         g2124)
-                                                                                                       ((top-level-value
-                                                                                                          'cdr)
-                                                                                                         g2114)))))))))))))])
-                                                           g2125)]))]))])
-                                              (g155 g2122))])
-                                          (g154 g2122))])
-                                      ((top-level-value 'car) g2114)))]))])
-                         (void)) g2106 g2107 g2108 '() '() '() '() '#f))])
-                  (case-lambda
-                    [(g2199 g2200 g2201 g2202 g2203 g2204 g2205)
-                     (begin
-                       (g161 g2105 g2202)
-                       ((top-level-value 'values) g2199 g2200 g2201 g2202
-                         g2203 g2204 g2205))]))])
-              (void))])
-         (case-lambda
-           [(g2206 g2207) (g102 (g42 g2206) (g129 g2207))])
-         (case-lambda
-           [(g2208)
-            ((case-lambda
-               [(g2209)
-                (begin
-                  (if ((top-level-value 'not) g2209)
-                      ((top-level-value 'syntax-error)
-                        g2208
-                        '"exported identifier not visible")
-                      (#%void))
-                  g2209)])
-              (g109 g2208 '(())))])
-         (case-lambda
-           [(g2210 g2211)
-            ((case-lambda
-               [(g2212)
-                (if ((top-level-value 'fx<=)
-                      ((top-level-value 'vector-length) g2212)
-                      '20)
-                    ((case-lambda
-                       [(g2213)
-                        (g164
-                          (case-lambda
-                            [(g2214) (g87 g2211 g2213 g2214 (g182 g2214))])
-                          g2212)])
-                      (g75 g2210))
-                    (g90 g2211 g2210))])
-              (g130 (g74 g2210)))])
-         (case-lambda
-           [(g2215 g2216 g2217 g2218)
-            ((case-lambda
-               [(g2219)
-                ((case-lambda
-                   [(g2220)
-                    (begin
-                      (set! g2219 g2220)
-                      ((case-lambda
-                         [(g2221)
-                          ((case-lambda
-                             [(g2222)
-                              (if (if g2222
-                                      (#%apply
-                                        (case-lambda
-                                          [(g2223 g2224 g2225 g2226 g2227)
-                                           (g41 g2225)])
-                                        g2222)
-                                      '#f)
-                                  (#%apply
-                                    (case-lambda
-                                      [(g2228 g2229 g2230 g2231 g2232)
-                                       ((top-level-value 'values)
-                                         g2229
-                                         (g119 g2230 g2216)
-                                         (g2219 g2231)
-                                         ((top-level-value 'map)
-                                           (case-lambda
-                                             [(g2233) (g119 g2233 g2218)])
-                                           g2232))])
-                                    g2222)
-                                  ((case-lambda
-                                     [(g2234)
-                                      ((top-level-value 'syntax-error)
-                                        (g120 g2215 g2216 g2217))])
-                                    g2221))])
-                            (#%$syntax-dispatch
-                              g2221
-                              '(any any any each-any . each-any)))])
-                        g2215))])
-                  (case-lambda
-                    [(g2235)
-                     (if ((top-level-value 'null?) g2235)
-                         '()
-                         ((top-level-value 'cons)
-                           ((case-lambda
-                              [(g2236)
-                               ((case-lambda
-                                  [(g2237)
-                                   (if g2237
-                                       (#%apply
-                                         (case-lambda
-                                           [(g2238) (g2219 g2238)])
-                                         g2237)
-                                       ((case-lambda
-                                          [(g2239)
-                                           (if (g41 g2239)
-                                               (g119 g2239 g2218)
-                                               ((top-level-value
-                                                  'syntax-error)
-                                                 (g120 g2215 g2216 g2217)
-                                                 '"invalid exports list in"))])
-                                         g2236))])
-                                 (#%$syntax-dispatch g2236 'each-any))])
-                             ((top-level-value 'car) g2235))
-                           (g2219 ((top-level-value 'cdr) g2235))))]))])
-              (void))])
-         (case-lambda
-           [(g2240 g2241 g2242)
-            ((case-lambda
-               [(g2243)
-                ((case-lambda
-                   [(g2244)
-                    (if (if g2244
-                            (#%apply
-                              (case-lambda
-                                [(g2245 g2246 g2247) (g41 g2247)])
-                              g2244)
-                            '#f)
-                        (#%apply
-                          (case-lambda
-                            [(g2248 g2249 g2250)
-                             ((top-level-value 'values)
-                               g2249
-                               '#t
-                               (g119 g2250 g2241))])
-                          g2244)
-                        ((case-lambda
-                           [(g2251)
-                            (if (if g2251
-                                    (#%apply
-                                      (case-lambda
-                                        [(g2252 g2253 g2254) (g41 g2254)])
-                                      g2251)
-                                    '#f)
-                                (#%apply
-                                  (case-lambda
-                                    [(g2255 g2256 g2257)
-                                     ((top-level-value 'values)
-                                       g2256
-                                       '#f
-                                       (g119 g2257 g2241))])
-                                  g2251)
-                                ((case-lambda
-                                   [(g2258)
-                                    ((top-level-value 'syntax-error)
-                                      (g120 g2240 g2241 g2242))])
-                                  g2243))])
-                          (#%$syntax-dispatch
-                            g2243
-                            '(any any #(atom #f) any))))])
-                  (#%$syntax-dispatch g2243 '(any any #(atom #t) any)))])
-              g2240)])
-         (case-lambda
-           [(g2259 g2260 g2261)
-            ((case-lambda
-               [(g2262)
-                ((case-lambda
-                   [(g2263)
-                    (if (if g2263
-                            (#%apply
-                              (case-lambda
-                                [(g2264 g2265 g2266) (g41 g2265)])
-                              g2263)
-                            '#f)
-                        (#%apply
-                          (case-lambda
-                            [(g2267 g2268 g2269)
-                             ((top-level-value 'values)
-                               g2268
-                               g2269
-                               g2260)])
-                          g2263)
-                        ((case-lambda
-                           [(g2270)
-                            (if (if g2270
-                                    (#%apply
-                                      (case-lambda
-                                        [(g2271 g2272 g2273 g2274 g2275)
-                                         (if (g41 g2272)
-                                             (g115 (g200 g2273))
-                                             '#f)])
-                                      g2270)
-                                    '#f)
-                                (#%apply
-                                  (case-lambda
-                                    [(g2276 g2277 g2278 g2279 g2280)
-                                     ((top-level-value 'values)
-                                       (g119 g2277 g2260)
-                                       ((top-level-value 'cons)
-                                         '#(syntax-object lambda
-                                            ((top)
-                                              #(ribcage
-                                                #(_ name args e1 e2)
-                                                #((top) (top) (top) (top)
-                                                  (top))
-                                                #("i" "i" "i" "i" "i"))
-                                              #(ribcage () () ())
-                                              #(ribcage #(e w ae)
-                                                #((top) (top) (top))
-                                                #("i" "i" "i"))
-                                              #(ribcage
-                                                (lambda-var-list gen-var
-                                                 strip strip*
-                                                 strip-annotation ellipsis?
-                                                 chi-void chi-local-syntax
-                                                 chi-lambda-clause
-                                                 parse-begin parse-alias
-                                                 parse-eval-when parse-meta
-                                                 parse-define-syntax
-                                                 parse-define parse-import
-                                                 parse-module do-import!
-                                                 lookup-import-label
-                                                 import-mark-delta
-                                                 chi-internal chi-body
-                                                 chi-macro chi-set!
-                                                 chi-application chi-expr
-                                                 chi chi-sequence
-                                                 chi-meta-frob chi-frobs
-                                                 ct-eval/residualize3
-                                                 ct-eval/residualize2
-                                                 rt-eval/residualize
-                                                 initial-mode-set
-                                                 update-mode-set
-                                                 do-top-import vfor-each
-                                                 vmap chi-external
-                                                 check-defined-ids
-                                                 check-module-exports
-                                                 id-set-diff chi-top-module
-                                                 set-frob-meta?!
-                                                 set-frob-e! frob-meta?
-                                                 frob-e frob? make-frob
-                                                 create-module-binding
-                                                 set-module-binding-exported!
-                                                 set-module-binding-val!
-                                                 set-module-binding-imps!
-                                                 set-module-binding-label!
-                                                 set-module-binding-id!
-                                                 set-module-binding-type!
-                                                 module-binding-exported
-                                                 module-binding-val
-                                                 module-binding-imps
-                                                 module-binding-label
-                                                 module-binding-id
-                                                 module-binding-type
-                                                 module-binding?
-                                                 make-module-binding
-                                                 make-resolved-interface
-                                                 make-unresolved-interface
-                                                 set-interface-token!
-                                                 set-interface-exports!
-                                                 set-interface-marks!
-                                                 interface-token
-                                                 interface-exports
-                                                 interface-marks interface?
-                                                 make-interface
-                                                 flatten-exports chi-top
-                                                 chi-top-sequence chi-top*
-                                                 syntax-type chi-when-list
-                                                 source-wrap wrap
-                                                 bound-id-member?
-                                                 invalid-ids-error
-                                                 distinct-bound-ids?
-                                                 valid-bound-ids?
-                                                 bound-id=? help-bound-id=?
-                                                 literal-id=? free-id=?
-                                                 id-var-name
-                                                 id-var-name-loc
-                                                 id-var-name&marks
-                                                 id-var-name-loc&marks
-                                                 top-id-free-var-name
-                                                 top-id-bound-var-name anon
-                                                 diff-marks same-marks?
-                                                 join-subst join-marks
-                                                 join-wraps smart-append
-                                                 resolved-id-var-name
-                                                 id->resolved-id
-                                                 make-resolved-id
-                                                 make-binding-wrap
-                                                 store-import-binding
-                                                 lookup-import-binding-name
-                                                 extend-ribcage-subst!
-                                                 extend-ribcage-barrier-help!
-                                                 extend-ribcage-barrier!
-                                                 import-extend-ribcage!
-                                                 extend-ribcage!
-                                                 make-empty-ribcage
-                                                 barrier-marker new-mark
-                                                 anti-mark the-anti-mark
-                                                 set-env-wrap!
-                                                 set-env-top-ribcage!
-                                                 env-wrap env-top-ribcage
-                                                 env? make-env
-                                                 set-import-interface-new-marks!
-                                                 set-import-interface-interface!
-                                                 import-interface-new-marks
-                                                 import-interface-interface
-                                                 import-interface?
-                                                 make-import-interface
-                                                 set-top-ribcage-mutable?!
-                                                 set-top-ribcage-key!
-                                                 top-ribcage-mutable?
-                                                 top-ribcage-key
-                                                 top-ribcage?
-                                                 make-top-ribcage
-                                                 set-ribcage-labels!
-                                                 set-ribcage-marks!
-                                                 set-ribcage-symnames!
-                                                 ribcage-labels
-                                                 ribcage-marks
-                                                 ribcage-symnames ribcage?
-                                                 make-ribcage gen-labels
-                                                 label? gen-label
-                                                 set-indirect-label!
-                                                 get-indirect-label
-                                                 indirect-label?
-                                                 gen-indirect-label anon
-                                                 only-top-marked?
-                                                 top-marked? top-wrap
-                                                 empty-wrap wrap-subst
-                                                 wrap-marks make-wrap
-                                                 id-sym-name&marks id-subst
-                                                 id-marks id-sym-name id?
-                                                 nonsymbol-id?
-                                                 global-extend
-                                                 defer-or-eval-transformer
-                                                 make-transformer-binding
-                                                 lookup lookup*
-                                                 displaced-lexical-error
-                                                 displaced-lexical?
-                                                 extend-var-env*
-                                                 extend-env* extend-env
-                                                 null-env binding?
-                                                 set-binding-value!
-                                                 set-binding-type!
-                                                 binding-value binding-type
-                                                 make-binding
-                                                 sanitize-binding arg-check
-                                                 no-source unannotate
-                                                 self-evaluating?
-                                                 lexical-var?
-                                                 build-lexical-var
-                                                 build-top-module
-                                                 build-body build-letrec
-                                                 build-sequence build-data
-                                                 build-primref
-                                                 built-lambda? build-lambda
-                                                 build-revisit-only
-                                                 build-visit-only
-                                                 build-cte-install
-                                                 build-global-definition
-                                                 build-global-assignment
-                                                 build-global-reference
-                                                 build-lexical-assignment
-                                                 build-lexical-reference
-                                                 build-conditional
-                                                 build-application
-                                                 generate-id
-                                                 put-import-binding
-                                                 get-import-binding
-                                                 read-only-binding?
-                                                 put-global-definition-hook
-                                                 get-global-definition-hook
-                                                 put-cte-hook gensym-hook
-                                                 error-hook
-                                                 define-top-level-value-hook
-                                                 local-eval-hook
-                                                 top-level-eval-hook
-                                                 annotation?
-                                                 set-syntax-object-wrap!
-                                                 set-syntax-object-expression!
-                                                 syntax-object-wrap
-                                                 syntax-object-expression
-                                                 syntax-object?
-                                                 make-syntax-object
-                                                 noexpand let-values
-                                                 define-structure unless
-                                                 when)
-                                                ((top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 ("m" top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) ("m" top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top) (top) (top)
-                                                 (top) (top))
-                                                ("i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i" "i" "i"
-                                                 "i" "i" "i" "i"))
-                                              #(top-ribcage *top* #t)))
-                                         (g119
-                                           (#%cons
-                                             g2278
-                                             (#%cons g2279 g2280))
-                                           g2260))
-                                       '(()))])
-                                  g2270)
-                                ((case-lambda
-                                   [(g2281)
-                                    (if (if g2281
-                                            (#%apply
-                                              (case-lambda
-                                                [(g2282 g2283)
-                                                 (g41 g2283)])
-                                              g2281)
-                                            '#f)
-                                        (#%apply
-                                          (case-lambda
-                                            [(g2284 g2285)
-                                             ((top-level-value 'values)
-                                               (g119 g2285 g2260)
-                                               '#(syntax-object (void)
-                                                  ((top)
-                                                    #(ribcage #(_ name)
-                                                      #((top) (top))
-                                                      #("i" "i"))
-                                                    #(ribcage () () ())
-                                                    #(ribcage #(e w ae)
-                                                      #((top) (top) (top))
-                                                      #("i" "i" "i"))
-                                                    #(ribcage
-                                                      (lambda-var-list
-                                                       gen-var strip strip*
-                                                       strip-annotation
-                                                       ellipsis? chi-void
-                                                       chi-local-syntax
-                                                       chi-lambda-clause
-                                                       parse-begin
-                                                       parse-alias
-                                                       parse-eval-when
-                                                       parse-meta
-                                                       parse-define-syntax
-                                                       parse-define
-                                                       parse-import
-                                                       parse-module
-                                                       do-import!
-                                                       lookup-import-label
-                                                       import-mark-delta
-                                                       chi-internal
-                                                       chi-body chi-macro
-                                                       chi-set!
-                                                       chi-application
-                                                       chi-expr chi
-                                                       chi-sequence
-                                                       chi-meta-frob
-                                                       chi-frobs
-                                                       ct-eval/residualize3
-                                                       ct-eval/residualize2
-                                                       rt-eval/residualize
-                                                       initial-mode-set
-                                                       update-mode-set
-                                                       do-top-import
-                                                       vfor-each vmap
-                                                       chi-external
-                                                       check-defined-ids
-                                                       check-module-exports
-                                                       id-set-diff
-                                                       chi-top-module
-                                                       set-frob-meta?!
-                                                       set-frob-e!
-                                                       frob-meta? frob-e
-                                                       frob? make-frob
-                                                       create-module-binding
-                                                       set-module-binding-exported!
-                                                       set-module-binding-val!
-                                                       set-module-binding-imps!
-                                                       set-module-binding-label!
-                                                       set-module-binding-id!
-                                                       set-module-binding-type!
-                                                       module-binding-exported
-                                                       module-binding-val
-                                                       module-binding-imps
-                                                       module-binding-label
-                                                       module-binding-id
-                                                       module-binding-type
-                                                       module-binding?
-                                                       make-module-binding
-                                                       make-resolved-interface
-                                                       make-unresolved-interface
-                                                       set-interface-token!
-                                                       set-interface-exports!
-                                                       set-interface-marks!
-                                                       interface-token
-                                                       interface-exports
-                                                       interface-marks
-                                                       interface?
-                                                       make-interface
-                                                       flatten-exports
-                                                       chi-top
-                                                       chi-top-sequence
-                                                       chi-top* syntax-type
-                                                       chi-when-list
-                                                       source-wrap wrap
-                                                       bound-id-member?
-                                                       invalid-ids-error
-                                                       distinct-bound-ids?
-                                                       valid-bound-ids?
-                                                       bound-id=?
-                                                       help-bound-id=?
-                                                       literal-id=?
-                                                       free-id=?
-                                                       id-var-name
-                                                       id-var-name-loc
-                                                       id-var-name&marks
-                                                       id-var-name-loc&marks
-                                                       top-id-free-var-name
-                                                       top-id-bound-var-name
-                                                       anon diff-marks
-                                                       same-marks?
-                                                       join-subst
-                                                       join-marks
-                                                       join-wraps
-                                                       smart-append
-                                                       resolved-id-var-name
-                                                       id->resolved-id
-                                                       make-resolved-id
-                                                       make-binding-wrap
-                                                       store-import-binding
-                                                       lookup-import-binding-name
-                                                       extend-ribcage-subst!
-                                                       extend-ribcage-barrier-help!
-                                                       extend-ribcage-barrier!
-                                                       import-extend-ribcage!
-                                                       extend-ribcage!
-                                                       make-empty-ribcage
-                                                       barrier-marker
-                                                       new-mark anti-mark
-                                                       the-anti-mark
-                                                       set-env-wrap!
-                                                       set-env-top-ribcage!
-                                                       env-wrap
-                                                       env-top-ribcage env?
-                                                       make-env
-                                                       set-import-interface-new-marks!
-                                                       set-import-interface-interface!
-                                                       import-interface-new-marks
-                                                       import-interface-interface
-                                                       import-interface?
-                                                       make-import-interface
-                                                       set-top-ribcage-mutable?!
-                                                       set-top-ribcage-key!
-                                                       top-ribcage-mutable?
-                                                       top-ribcage-key
-                                                       top-ribcage?
-                                                       make-top-ribcage
-                                                       set-ribcage-labels!
-                                                       set-ribcage-marks!
-                                                       set-ribcage-symnames!
-                                                       ribcage-labels
-                                                       ribcage-marks
-                                                       ribcage-symnames
-                                                       ribcage?
-                                                       make-ribcage
-                                                       gen-labels label?
-                                                       gen-label
-                                                       set-indirect-label!
-                                                       get-indirect-label
-                                                       indirect-label?
-                                                       gen-indirect-label
-                                                       anon
-                                                       only-top-marked?
-                                                       top-marked? top-wrap
-                                                       empty-wrap
-                                                       wrap-subst
-                                                       wrap-marks make-wrap
-                                                       id-sym-name&marks
-                                                       id-subst id-marks
-                                                       id-sym-name id?
-                                                       nonsymbol-id?
-                                                       global-extend
-                                                       defer-or-eval-transformer
-                                                       make-transformer-binding
-                                                       lookup lookup*
-                                                       displaced-lexical-error
-                                                       displaced-lexical?
-                                                       extend-var-env*
-                                                       extend-env*
-                                                       extend-env null-env
-                                                       binding?
-                                                       set-binding-value!
-                                                       set-binding-type!
-                                                       binding-value
-                                                       binding-type
-                                                       make-binding
-                                                       sanitize-binding
-                                                       arg-check no-source
-                                                       unannotate
-                                                       self-evaluating?
-                                                       lexical-var?
-                                                       build-lexical-var
-                                                       build-top-module
-                                                       build-body
-                                                       build-letrec
-                                                       build-sequence
-                                                       build-data
-                                                       build-primref
-                                                       built-lambda?
-                                                       build-lambda
-                                                       build-revisit-only
-                                                       build-visit-only
-                                                       build-cte-install
-                                                       build-global-definition
-                                                       build-global-assignment
-                                                       build-global-reference
-                                                       build-lexical-assignment
-                                                       build-lexical-reference
-                                                       build-conditional
-                                                       build-application
-                                                       generate-id
-                                                       put-import-binding
-                                                       get-import-binding
-                                                       read-only-binding?
-                                                       put-global-definition-hook
-                                                       get-global-definition-hook
-                                                       put-cte-hook
-                                                       gensym-hook
-                                                       error-hook
-                                                       define-top-level-value-hook
-                                                       local-eval-hook
-                                                       top-level-eval-hook
-                                                       annotation?
-                                                       set-syntax-object-wrap!
-                                                       set-syntax-object-expression!
-                                                       syntax-object-wrap
-                                                       syntax-object-expression
-                                                       syntax-object?
-                                                       make-syntax-object
-                                                       noexpand let-values
-                                                       define-structure
-                                                       unless when)
-                                                      ((top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       ("m" top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       ("m" top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top))
-                                                      ("i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i" "i"
-                                                       "i" "i"))
-                                                    #(top-ribcage *top*
-                                                      #t)))
-                                               '(()))])
-                                          g2281)
-                                        ((case-lambda
-                                           [(g2286)
-                                            ((top-level-value
-                                               'syntax-error)
-                                              (g120 g2259 g2260 g2261))])
-                                          g2262))])
-                                  (#%$syntax-dispatch g2262 '(any any))))])
-                          (#%$syntax-dispatch
-                            g2262
-                            '(any (any . any) any . each-any))))])
-                  (#%$syntax-dispatch g2262 '(any any any)))])
-              g2259)])
-         (case-lambda
-           [(g2287 g2288 g2289)
-            ((case-lambda
-               [(g2290)
-                ((case-lambda
-                   [(g2291)
-                    (if (if g2291
-                            (#%apply
-                              (case-lambda
-                                [(g2292 g2293 g2294 g2295 g2296)
-                                 (if (g41 g2293) (g41 g2294) '#f)])
-                              g2291)
-                            '#f)
-                        (#%apply
-                          (case-lambda
-                            [(g2297 g2298 g2299 g2300 g2301)
-                             ((top-level-value 'values)
-                               (g119 g2298 g2288)
-                               ((top-level-value 'cons)
-                                 '#(syntax-object lambda
-                                    ((top)
-                                      #(ribcage #(_ name id e1 e2)
-                                        #((top) (top) (top) (top) (top))
-                                        #("i" "i" "i" "i" "i"))
-                                      #(ribcage () () ())
-                                      #(ribcage #(e w ae)
-                                        #((top) (top) (top))
-                                        #("i" "i" "i"))
-                                      #(ribcage
-                                        (lambda-var-list gen-var strip
-                                         strip* strip-annotation ellipsis?
-                                         chi-void chi-local-syntax
-                                         chi-lambda-clause parse-begin
-                                         parse-alias parse-eval-when
-                                         parse-meta parse-define-syntax
-                                         parse-define parse-import
-                                         parse-module do-import!
-                                         lookup-import-label
-                                         import-mark-delta chi-internal
-                                         chi-body chi-macro chi-set!
-                                         chi-application chi-expr chi
-                                         chi-sequence chi-meta-frob
-                                         chi-frobs ct-eval/residualize3
-                                         ct-eval/residualize2
-                                         rt-eval/residualize
-                                         initial-mode-set update-mode-set
-                                         do-top-import vfor-each vmap
-                                         chi-external check-defined-ids
-                                         check-module-exports id-set-diff
-                                         chi-top-module set-frob-meta?!
-                                         set-frob-e! frob-meta? frob-e
-                                         frob? make-frob
-                                         create-module-binding
-                                         set-module-binding-exported!
-                                         set-module-binding-val!
-                                         set-module-binding-imps!
-                                         set-module-binding-label!
-                                         set-module-binding-id!
-                                         set-module-binding-type!
-                                         module-binding-exported
-                                         module-binding-val
-                                         module-binding-imps
-                                         module-binding-label
-                                         module-binding-id
-                                         module-binding-type
-                                         module-binding?
-                                         make-module-binding
-                                         make-resolved-interface
-                                         make-unresolved-interface
-                                         set-interface-token!
-                                         set-interface-exports!
-                                         set-interface-marks!
-                                         interface-token interface-exports
-                                         interface-marks interface?
-                                         make-interface flatten-exports
-                                         chi-top chi-top-sequence chi-top*
-                                         syntax-type chi-when-list
-                                         source-wrap wrap bound-id-member?
-                                         invalid-ids-error
-                                         distinct-bound-ids?
-                                         valid-bound-ids? bound-id=?
-                                         help-bound-id=? literal-id=?
-                                         free-id=? id-var-name
-                                         id-var-name-loc id-var-name&marks
-                                         id-var-name-loc&marks
-                                         top-id-free-var-name
-                                         top-id-bound-var-name anon
-                                         diff-marks same-marks? join-subst
-                                         join-marks join-wraps smart-append
-                                         resolved-id-var-name
-                                         id->resolved-id make-resolved-id
-                                         make-binding-wrap
-                                         store-import-binding
-                                         lookup-import-binding-name
-                                         extend-ribcage-subst!
-                                         extend-ribcage-barrier-help!
-                                         extend-ribcage-barrier!
-                                         import-extend-ribcage!
-                                         extend-ribcage! make-empty-ribcage
-                                         barrier-marker new-mark anti-mark
-                                         the-anti-mark set-env-wrap!
-                                         set-env-top-ribcage! env-wrap
-                                         env-top-ribcage env? make-env
-                                         set-import-interface-new-marks!
-                                         set-import-interface-interface!
-                                         import-interface-new-marks
-                                         import-interface-interface
-                                         import-interface?
-                                         make-import-interface
-                                         set-top-ribcage-mutable?!
-                                         set-top-ribcage-key!
-                                         top-ribcage-mutable?
-                                         top-ribcage-key top-ribcage?
-                                         make-top-ribcage
-                                         set-ribcage-labels!
-                                         set-ribcage-marks!
-                                         set-ribcage-symnames!
-                                         ribcage-labels ribcage-marks
-                                         ribcage-symnames ribcage?
-                                         make-ribcage gen-labels label?
-                                         gen-label set-indirect-label!
-                                         get-indirect-label indirect-label?
-                                         gen-indirect-label anon
-                                         only-top-marked? top-marked?
-                                         top-wrap empty-wrap wrap-subst
-                                         wrap-marks make-wrap
-                                         id-sym-name&marks id-subst
-                                         id-marks id-sym-name id?
-                                         nonsymbol-id? global-extend
-                                         defer-or-eval-transformer
-                                         make-transformer-binding lookup
-                                         lookup* displaced-lexical-error
-                                         displaced-lexical? extend-var-env*
-                                         extend-env* extend-env null-env
-                                         binding? set-binding-value!
-                                         set-binding-type! binding-value
-                                         binding-type make-binding
-                                         sanitize-binding arg-check
-                                         no-source unannotate
-                                         self-evaluating? lexical-var?
-                                         build-lexical-var build-top-module
-                                         build-body build-letrec
-                                         build-sequence build-data
-                                         build-primref built-lambda?
-                                         build-lambda build-revisit-only
-                                         build-visit-only build-cte-install
-                                         build-global-definition
-                                         build-global-assignment
-                                         build-global-reference
-                                         build-lexical-assignment
-                                         build-lexical-reference
-                                         build-conditional
-                                         build-application generate-id
-                                         put-import-binding
-                                         get-import-binding
-                                         read-only-binding?
-                                         put-global-definition-hook
-                                         get-global-definition-hook
-                                         put-cte-hook gensym-hook
-                                         error-hook
-                                         define-top-level-value-hook
-                                         local-eval-hook
-                                         top-level-eval-hook annotation?
-                                         set-syntax-object-wrap!
-                                         set-syntax-object-expression!
-                                         syntax-object-wrap
-                                         syntax-object-expression
-                                         syntax-object? make-syntax-object
-                                         noexpand let-values
-                                         define-structure unless when)
-                                        ((top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) ("m" top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) ("m" top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top) (top) (top) (top)
-                                         (top) (top))
-                                        ("i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"
-                                         "i" "i" "i" "i" "i" "i" "i" "i"))
-                                      #(top-ribcage *top* #t)))
-                                 ((top-level-value 'cons)
-                                   (g119 (#%list g2299) g2288)
-                                   (g119 (#%cons g2300 g2301) g2288)))
-                               '(()))])
-                          g2291)
-                        ((case-lambda
-                           [(g2302)
-                            (if (if g2302
-                                    (#%apply
-                                      (case-lambda
-                                        [(g2303 g2304 g2305) (g41 g2304)])
-                                      g2302)
-                                    '#f)
-                                (#%apply
-                                  (case-lambda
-                                    [(g2306 g2307 g2308)
-                                     ((top-level-value 'values)
-                                       g2307
-                                       g2308
-                                       g2288)])
-                                  g2302)
-                                ((case-lambda
-                                   [(g2309)
-                                    ((top-level-value 'syntax-error)
-                                      (g120 g2287 g2288 g2289))])
-                                  g2290))])
-                          (#%$syntax-dispatch g2290 '(any any any))))])
-                  (#%$syntax-dispatch
-                    g2290
-                    '(any (any any) any . each-any)))])
-              g2287)])
-         (case-lambda
-           [(g2310 g2311 g2312)
-            ((case-lambda
-               [(g2313)
-                ((case-lambda
-                   [(g2314)
-                    (if g2314
-                        (#%apply (case-lambda [(g2315 g2316) g2316]) g2314)
-                        ((case-lambda
-                           [(g2317)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2310 g2311 g2312))])
-                          g2313))])
-                  (#%$syntax-dispatch g2313 '(any . any)))])
-              g2310)])
-         (case-lambda
-           [(g2318 g2319 g2320)
-            ((case-lambda
-               [(g2321)
-                ((case-lambda
-                   [(g2322)
-                    (if g2322
-                        (#%apply
-                          (case-lambda
-                            [(g2323 g2324 g2325 g2326)
-                             ((top-level-value 'values)
-                               (g121 g2324 g2319)
-                               (#%cons g2325 g2326))])
-                          g2322)
-                        ((case-lambda
-                           [(g2327)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2318 g2319 g2320))])
-                          g2321))])
-                  (#%$syntax-dispatch
-                    g2321
-                    '(any each-any any . each-any)))])
-              g2318)])
-         (case-lambda
-           [(g2328 g2329 g2330)
-            ((case-lambda
-               [(g2331)
-                ((case-lambda
-                   [(g2332)
-                    (if (if g2332
-                            (#%apply
-                              (case-lambda
-                                [(g2333 g2334 g2335)
-                                 (if (g41 g2334) (g41 g2335) '#f)])
-                              g2332)
-                            '#f)
-                        (#%apply
-                          (case-lambda
-                            [(g2336 g2337 g2338)
-                             ((top-level-value 'values) g2337 g2338)])
-                          g2332)
-                        ((case-lambda
-                           [(g2339)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2328 g2329 g2330))])
-                          g2331))])
-                  (#%$syntax-dispatch g2331 '(any any any)))])
-              g2328)])
-         (case-lambda
-           [(g2340 g2341 g2342 g2343)
-            ((case-lambda
-               [(g2344)
-                ((case-lambda
-                   [(g2345)
-                    (if (if g2345
-                            (#%apply (case-lambda [(g2346) g2343]) g2345)
-                            '#f)
-                        (#%apply (case-lambda [(g2347) '()]) g2345)
-                        ((case-lambda
-                           [(g2348)
-                            (if g2348
-                                (#%apply
-                                  (case-lambda
-                                    [(g2349 g2350 g2351)
-                                     (#%cons g2350 g2351)])
-                                  g2348)
-                                ((case-lambda
-                                   [(g2352)
-                                    ((top-level-value 'syntax-error)
-                                      (g120 g2340 g2341 g2342))])
-                                  g2344))])
-                          (#%$syntax-dispatch
-                            g2344
-                            '(any any . each-any))))])
-                  (#%$syntax-dispatch g2344 '(any)))])
-              g2340)])
-         (case-lambda
-           [(g2353 g2354 g2355 g2356 g2357 g2358)
-            ((case-lambda
-               [(g2359)
-                ((case-lambda
-                   [(g2360)
-                    (if g2360
-                        (#%apply
-                          (case-lambda
-                            [(g2361 g2362 g2363)
-                             ((case-lambda
-                                [(g2364)
-                                 (if ((top-level-value 'not) (g115 g2364))
-                                     ((top-level-value 'syntax-error)
-                                       g2353
-                                       '"invalid parameter list in")
-                                     ((case-lambda
-                                        [(g2365 g2366)
-                                         ((top-level-value 'values)
-                                           g2366
-                                           (g179 (#%cons g2362 g2363) g2353
-                                             (g32 g2365 g2366 g2355) g2356
-                                             (g93 g2364 g2365 g2357)
-                                             g2358))])
-                                       (g57 g2364)
-                                       ((top-level-value 'map)
-                                         g199
-                                         g2364)))])
-                               g2361)])
-                          g2360)
-                        ((case-lambda
-                           [(g2367)
-                            (if g2367
-                                (#%apply
-                                  (case-lambda
-                                    [(g2368 g2369 g2370)
-                                     ((case-lambda
-                                        [(g2371)
-                                         (if ((top-level-value 'not)
-                                               (g115 g2371))
-                                             ((top-level-value
-                                                'syntax-error)
-                                               g2353
-                                               '"invalid parameter list in")
-                                             ((case-lambda
-                                                [(g2372 g2373)
-                                                 ((top-level-value 'values)
-                                                   (((case-lambda
-                                                       [(g2374)
-                                                        ((case-lambda
-                                                           [(g2375)
-                                                            (begin
-                                                              (set! g2374
-                                                                g2375)
-                                                              g2374)])
-                                                          (case-lambda
-                                                            [(g2376 g2377)
-                                                             (if ((top-level-value
-                                                                    'null?)
-                                                                   g2376)
-                                                                 g2377
-                                                                 (g2374
-                                                                   ((top-level-value
-                                                                      'cdr)
-                                                                     g2376)
-                                                                   ((top-level-value
-                                                                      'cons)
-                                                                     ((top-level-value
-                                                                        'car)
-                                                                       g2376)
-                                                                     g2377)))]))])
-                                                      (void))
-                                                     ((top-level-value
-                                                        'cdr)
-                                                       g2373)
-                                                     ((top-level-value
-                                                        'car)
-                                                       g2373))
-                                                   (g179
-                                                     (#%cons g2369 g2370)
-                                                     g2353
-                                                     (g32 g2372
-                                                          g2373
-                                                          g2355)
-                                                     g2356
-                                                     (g93 g2371
-                                                          g2372
-                                                          g2357)
-                                                     g2358))])
-                                               (g57 g2371)
-                                               ((top-level-value 'map)
-                                                 g199
-                                                 g2371)))])
-                                       (g200 g2368))])
-                                  g2367)
-                                ((case-lambda
-                                   [(g2378)
-                                    ((top-level-value 'syntax-error)
-                                      g2353)])
-                                  g2359))])
-                          (#%$syntax-dispatch
-                            g2359
-                            '(any any . each-any))))])
-                  (#%$syntax-dispatch g2359 '(each-any any . each-any)))])
-              g2354)])
-         (case-lambda
-           [(g2379 g2380 g2381 g2382 g2383 g2384)
-            ((case-lambda
-               [(g2385)
-                ((case-lambda
-                   [(g2386)
-                    (if g2386
-                        (#%apply
-                          (case-lambda
-                            [(g2387 g2388 g2389 g2390 g2391)
-                             ((case-lambda
-                                [(g2392)
-                                 (if ((top-level-value 'not) (g115 g2392))
-                                     (g117
-                                       ((top-level-value 'map)
-                                         (case-lambda
-                                           [(g2393) (g119 g2393 g2383)])
-                                         g2392)
-                                       (g120 g2380 g2383 g2384)
-                                       '"keyword")
-                                     ((case-lambda
-                                        [(g2394)
-                                         ((case-lambda
-                                            [(g2395)
-                                             ((case-lambda
-                                                [(g2396)
-                                                 ((top-level-value 'values)
-                                                   (#%cons g2390 g2391)
-                                                   (g31 g2394 g2396 g2381)
-                                                   (g31 g2394 g2396 g2382)
-                                                   g2395 g2384)])
-                                               ((case-lambda
-                                                  [(g2397)
-                                                   ((top-level-value 'map)
-                                                     (case-lambda
-                                                       [(g2398)
-                                                        (g38 g9
-                                                             (g174 g2398
-                                                               g2382 g2382
-                                                               g2397
-                                                               '#t))])
-                                                     g2389)])
-                                                 (if g2379 g2395 g2383)))])
-                                           (g93 g2392 g2394 g2383))])
-                                       (g57 g2392)))])
-                               g2388)])
-                          g2386)
-                        ((case-lambda
-                           [(g2399)
-                            ((top-level-value 'syntax-error)
-                              (g120 g2380 g2383 g2384))])
-                          g2385))])
-                  (#%$syntax-dispatch
-                    g2385
-                    '(any #(each (any any)) any . each-any)))])
-              g2380)])
-         (case-lambda [() ((top-level-value 'list) '#%void)])
-         (case-lambda
-           [(g2400)
-            (if (g40 g2400)
-                (g112
-                  g2400
-                  '#(syntax-object ...
-                     ((top)
-                       #(ribcage () () ())
-                       #(ribcage #(x) #((top)) #("i"))
-                       #(ribcage
-                         (lambda-var-list gen-var strip strip*
-                          strip-annotation ellipsis? chi-void
-                          chi-local-syntax chi-lambda-clause parse-begin
-                          parse-alias parse-eval-when parse-meta
-                          parse-define-syntax parse-define parse-import
-                          parse-module do-import! lookup-import-label
-                          import-mark-delta chi-internal chi-body chi-macro
-                          chi-set! chi-application chi-expr chi
-                          chi-sequence chi-meta-frob chi-frobs
-                          ct-eval/residualize3 ct-eval/residualize2
-                          rt-eval/residualize initial-mode-set
-                          update-mode-set do-top-import vfor-each vmap
-                          chi-external check-defined-ids
-                          check-module-exports id-set-diff chi-top-module
-                          set-frob-meta?! set-frob-e! frob-meta? frob-e
-                          frob? make-frob create-module-binding
-                          set-module-binding-exported!
-                          set-module-binding-val! set-module-binding-imps!
-                          set-module-binding-label! set-module-binding-id!
-                          set-module-binding-type! module-binding-exported
-                          module-binding-val module-binding-imps
-                          module-binding-label module-binding-id
-                          module-binding-type module-binding?
-                          make-module-binding make-resolved-interface
-                          make-unresolved-interface set-interface-token!
-                          set-interface-exports! set-interface-marks!
-                          interface-token interface-exports interface-marks
-                          interface? make-interface flatten-exports chi-top
-                          chi-top-sequence chi-top* syntax-type
-                          chi-when-list source-wrap wrap bound-id-member?
-                          invalid-ids-error distinct-bound-ids?
-                          valid-bound-ids? bound-id=? help-bound-id=?
-                          literal-id=? free-id=? id-var-name
-                          id-var-name-loc id-var-name&marks
-                          id-var-name-loc&marks top-id-free-var-name
-                          top-id-bound-var-name anon diff-marks same-marks?
-                          join-subst join-marks join-wraps smart-append
-                          resolved-id-var-name id->resolved-id
-                          make-resolved-id make-binding-wrap
-                          store-import-binding lookup-import-binding-name
-                          extend-ribcage-subst!
-                          extend-ribcage-barrier-help!
-                          extend-ribcage-barrier! import-extend-ribcage!
-                          extend-ribcage! make-empty-ribcage barrier-marker
-                          new-mark anti-mark the-anti-mark set-env-wrap!
-                          set-env-top-ribcage! env-wrap env-top-ribcage
-                          env? make-env set-import-interface-new-marks!
-                          set-import-interface-interface!
-                          import-interface-new-marks
-                          import-interface-interface import-interface?
-                          make-import-interface set-top-ribcage-mutable?!
-                          set-top-ribcage-key! top-ribcage-mutable?
-                          top-ribcage-key top-ribcage? make-top-ribcage
-                          set-ribcage-labels! set-ribcage-marks!
-                          set-ribcage-symnames! ribcage-labels
-                          ribcage-marks ribcage-symnames ribcage?
-                          make-ribcage gen-labels label? gen-label
-                          set-indirect-label! get-indirect-label
-                          indirect-label? gen-indirect-label anon
-                          only-top-marked? top-marked? top-wrap empty-wrap
-                          wrap-subst wrap-marks make-wrap id-sym-name&marks
-                          id-subst id-marks id-sym-name id? nonsymbol-id?
-                          global-extend defer-or-eval-transformer
-                          make-transformer-binding lookup lookup*
-                          displaced-lexical-error displaced-lexical?
-                          extend-var-env* extend-env* extend-env null-env
-                          binding? set-binding-value! set-binding-type!
-                          binding-value binding-type make-binding
-                          sanitize-binding arg-check no-source unannotate
-                          self-evaluating? lexical-var? build-lexical-var
-                          build-top-module build-body build-letrec
-                          build-sequence build-data build-primref
-                          built-lambda? build-lambda build-revisit-only
-                          build-visit-only build-cte-install
-                          build-global-definition build-global-assignment
-                          build-global-reference build-lexical-assignment
-                          build-lexical-reference build-conditional
-                          build-application generate-id put-import-binding
-                          get-import-binding read-only-binding?
-                          put-global-definition-hook
-                          get-global-definition-hook put-cte-hook
-                          gensym-hook error-hook
-                          define-top-level-value-hook local-eval-hook
-                          top-level-eval-hook annotation?
-                          set-syntax-object-wrap!
-                          set-syntax-object-expression! syntax-object-wrap
-                          syntax-object-expression syntax-object?
-                          make-syntax-object noexpand let-values
-                          define-structure unless when)
-                         ((top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          ("m" top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) ("m" top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top))
-                         ("i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i"
-                          "i" "i" "i" "i"))
-                       #(top-ribcage *top* #t))))
-                '#f)])
-         (case-lambda
-           [(g2401)
-            (if ((top-level-value 'pair?) g2401)
-                ((top-level-value 'cons)
-                  (g196 ((top-level-value 'car) g2401))
-                  (g196 ((top-level-value 'cdr) g2401)))
-                (if (g7 g2401)
-                    ((top-level-value 'annotation-stripped) g2401)
-                    g2401))])
-         (case-lambda
-           [(g2402 g2403 g2404)
-            (if ((top-level-value 'memq) 'top (g46 g2403))
-                (g2404 g2402)
-                (((case-lambda
-                    [(g2405)
-                     ((case-lambda
-                        [(g2406) (begin (set! g2405 g2406) g2405)])
-                       (case-lambda
-                         [(g2407)
-                          (if (g2 g2407)
-                              (g197 (g3 g2407) (g4 g2407) g2404)
-                              (if ((top-level-value 'pair?) g2407)
-                                  ((case-lambda
-                                     [(g2408 g2409)
-                                      (if (if ((top-level-value 'eq?)
-                                                g2408
-                                                ((top-level-value 'car)
-                                                  g2407))
-                                              ((top-level-value 'eq?)
-                                                g2409
-                                                ((top-level-value 'cdr)
-                                                  g2407))
-                                              '#f)
-                                          g2407
-                                          ((top-level-value 'cons)
-                                            g2408
-                                            g2409))])
-                                    (g2405 ((top-level-value 'car) g2407))
-                                    (g2405 ((top-level-value 'cdr) g2407)))
-                                  (if ((top-level-value 'vector?) g2407)
-                                      ((case-lambda
-                                         [(g2410)
-                                          ((case-lambda
-                                             [(g2411)
-                                              (if ((top-level-value
-                                                     'andmap)
-                                                    (top-level-value 'eq?)
-                                                    g2410
-                                                    g2411)
-                                                  g2407
-                                                  ((top-level-value
-                                                     'list->vector)
-                                                    g2411))])
-                                            ((top-level-value 'map)
-                                              g2405
-                                              g2410))])
-                                        ((top-level-value 'vector->list)
-                                          g2407))
-                                      g2407)))]))])
-                   (void))
-                  g2402))])
-         (case-lambda
-           [(g2412 g2413)
-            (g197
-              g2412
-              g2413
-              (case-lambda
-                [(g2414)
-                 (if ((case-lambda
-                        [(g2415)
-                         (if g2415
-                             g2415
-                             (if ((top-level-value 'pair?) g2414)
-                                 (g7 ((top-level-value 'car) g2414))
-                                 '#f))])
-                       (g7 g2414))
-                     (g196 g2414)
-                     g2414)]))])
-         (case-lambda
-           [(g2416)
-            ((case-lambda
-               [(g2417)
-                (if (g7 g2417)
-                    ((top-level-value 'gensym))
-                    ((top-level-value 'gensym)))])
-              (if (g2 g2416) (g3 g2416) g2416))])
-         (case-lambda
-           [(g2418)
-            (((case-lambda
-                [(g2419)
-                 ((case-lambda [(g2420) (begin (set! g2419 g2420) g2419)])
-                   (case-lambda
-                     [(g2421 g2422 g2423)
-                      (if ((top-level-value 'pair?) g2421)
-                          (g2419
-                            ((top-level-value 'cdr) g2421)
-                            ((top-level-value 'cons)
-                              (g119 ((top-level-value 'car) g2421) g2423)
-                              g2422)
-                            g2423)
-                          (if (g41 g2421)
-                              ((top-level-value 'cons)
-                                (g119 g2421 g2423)
-                                g2422)
-                              (if ((top-level-value 'null?) g2421)
-                                  g2422
-                                  (if (g2 g2421)
-                                      (g2419
-                                        (g3 g2421)
-                                        g2422
-                                        (g98 g2423 (g4 g2421)))
-                                      (if (g7 g2421)
-                                          (g2419
-                                            ((top-level-value
-                                               'annotation-expression)
-                                              g2421)
-                                            g2422
-                                            g2423)
-                                          ((top-level-value 'cons)
-                                            g2421
-                                            g2422))))))]))])
-               (void))
-              g2418
-              '()
-              '(()))]))])
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void) (void) (void) (void) (void) (void) (void) (void)
-     (void))]))
-
-(#%$sc-put-cte
-  '#(syntax-object with-syntax
-     ((top) #(ribcage #(with-syntax) #((top)) #(with-syntax))))
-  (case-lambda
-    [(g2424)
-     ((case-lambda
-        [(g2425)
-         ((case-lambda
-            [(g2426)
-             (if g2426
-                 (#%apply
-                   (case-lambda
-                     [(g2427 g2428 g2429)
-                      (#%cons
-                        '#(syntax-object begin
-                           ((top)
-                             #(ribcage #(_ e1 e2) #((top) (top) (top))
-                               #("i" "i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #((top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%cons g2428 g2429))])
-                   g2426)
-                 ((case-lambda
-                    [(g2430)
-                     (if g2430
-                         (#%apply
-                           (case-lambda
-                             [(g2431 g2432 g2433 g2434 g2435)
-                              (#%list
-                                '#(syntax-object syntax-case
-                                   ((top)
-                                     #(ribcage #(_ out in e1 e2)
-                                       #((top) (top) (top) (top) (top))
-                                       #("i" "i" "i" "i" "i"))
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #((top)) #("i"))
-                                     #(top-ribcage *top* #t)))
-                                g2433
-                                '()
-                                (#%list
-                                  g2432
-                                  (#%cons
-                                    '#(syntax-object begin
-                                       ((top)
-                                         #(ribcage #(_ out in e1 e2)
-                                           #((top) (top) (top) (top) (top))
-                                           #("i" "i" "i" "i" "i"))
-                                         #(ribcage () () ())
-                                         #(ribcage #(x) #((top)) #("i"))
-                                         #(top-ribcage *top* #t)))
-                                    (#%cons g2434 g2435))))])
-                           g2430)
-                         ((case-lambda
-                            [(g2436)
-                             (if g2436
-                                 (#%apply
-                                   (case-lambda
-                                     [(g2437 g2438 g2439 g2440 g2441)
-                                      (#%list
-                                        '#(syntax-object syntax-case
-                                           ((top)
-                                             #(ribcage #(_ out in e1 e2)
-                                               #((top) (top) (top) (top)
-                                                 (top))
-                                               #("i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #((top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        (#%cons
-                                          '#(syntax-object list
-                                             ((top)
-                                               #(ribcage #(_ out in e1 e2)
-                                                 #((top) (top) (top) (top)
-                                                   (top))
-                                                 #("i" "i" "i" "i" "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))
-                                          g2439)
-                                        '()
-                                        (#%list
-                                          g2438
-                                          (#%cons
-                                            '#(syntax-object begin
-                                               ((top)
-                                                 #(ribcage
-                                                   #(_ out in e1 e2)
-                                                   #((top) (top) (top)
-                                                     (top) (top))
-                                                   #("i" "i" "i" "i" "i"))
-                                                 #(ribcage () () ())
-                                                 #(ribcage #(x) #((top))
-                                                   #("i"))
-                                                 #(top-ribcage *top* #t)))
-                                            (#%cons g2440 g2441))))])
-                                   g2436)
-                                 (#%syntax-error g2425))])
-                           (#%$syntax-dispatch
-                             g2425
-                             '(any #(each (any any)) any . each-any))))])
-                   (#%$syntax-dispatch
-                     g2425
-                     '(any ((any any)) any . each-any))))])
-           (#%$syntax-dispatch g2425 '(any () any . each-any)))])
-       g2424)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object with-implicit
-     ((top)
-       #(ribcage #(with-implicit) #((top)) #(with-implicit))))
-  (case-lambda
-    [(g2442)
-     ((case-lambda
-        [(g2443)
-         ((case-lambda
-            [(g2444)
-             (if (if g2444
-                     (#%apply
-                       (case-lambda
-                         [(g2445 g2446 g2447 g2448 g2449)
-                          ((top-level-value 'andmap)
-                            (top-level-value 'identifier?)
-                            (#%cons g2446 g2447))])
-                       g2444)
-                     '#f)
-                 (#%apply
-                   (case-lambda
-                     [(g2450 g2451 g2452 g2453 g2454)
-                      (#%list
-                        '#(syntax-object begin
-                           ((top)
-                             #(ribcage #(dummy tid id e1 e2)
-                               #(("m" top) (top) (top) (top) (top))
-                               #("i" "i" "i" "i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #(("m" top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%list
-                          '#(syntax-object unless
-                             ((top)
-                               #(ribcage #(dummy tid id e1 e2)
-                                 #(("m" top) (top) (top) (top) (top))
-                                 #("i" "i" "i" "i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #(("m" top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          (#%list
-                            '#(syntax-object identifier?
-                               ((top)
-                                 #(ribcage #(dummy tid id e1 e2)
-                                   #(("m" top) (top) (top) (top) (top))
-                                   #("i" "i" "i" "i" "i"))
-                                 #(ribcage () () ())
-                                 #(ribcage #(x) #(("m" top)) #("i"))
-                                 #(top-ribcage *top* #t)))
-                            (#%list
-                              '#(syntax-object syntax
-                                 ((top)
-                                   #(ribcage #(dummy tid id e1 e2)
-                                     #(("m" top) (top) (top) (top) (top))
-                                     #("i" "i" "i" "i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t)))
-                              g2451))
-                          (#%cons
-                            '#(syntax-object syntax-error
-                               ((top)
-                                 #(ribcage #(dummy tid id e1 e2)
-                                   #(("m" top) (top) (top) (top) (top))
-                                   #("i" "i" "i" "i" "i"))
-                                 #(ribcage () () ())
-                                 #(ribcage #(x) #(("m" top)) #("i"))
-                                 #(top-ribcage *top* #t)))
-                            (#%cons
-                              (#%list
-                                '#(syntax-object syntax
-                                   ((top)
-                                     #(ribcage #(dummy tid id e1 e2)
-                                       #(("m" top) (top) (top) (top) (top))
-                                       #("i" "i" "i" "i" "i"))
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #(("m" top)) #("i"))
-                                     #(top-ribcage *top* #t)))
-                                g2451)
-                              '#(syntax-object
-                                 ("non-identifier with-implicit template")
-                                 ((top)
-                                   #(ribcage #(dummy tid id e1 e2)
-                                     #(("m" top) (top) (top) (top) (top))
-                                     #("i" "i" "i" "i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t))))))
-                        (#%cons
-                          '#(syntax-object with-syntax
-                             ((top)
-                               #(ribcage #(dummy tid id e1 e2)
-                                 #(("m" top) (top) (top) (top) (top))
-                                 #("i" "i" "i" "i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #(("m" top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          (#%cons
-                            (#%map
-                              (case-lambda
-                                [(g2455)
-                                 (#%list
-                                   g2455
-                                   (#%list
-                                     '#(syntax-object datum->syntax-object
-                                        ((top)
-                                          #(ribcage #(dummy tid id e1 e2)
-                                            #(("m" top) (top) (top) (top)
-                                              (top))
-                                            #("i" "i" "i" "i" "i"))
-                                          #(ribcage () () ())
-                                          #(ribcage #(x) #(("m" top))
-                                            #("i"))
-                                          #(top-ribcage *top* #t)))
-                                     (#%list
-                                       '#(syntax-object syntax
-                                          ((top)
-                                            #(ribcage #(dummy tid id e1 e2)
-                                              #(("m" top) (top) (top) (top)
-                                                (top))
-                                              #("i" "i" "i" "i" "i"))
-                                            #(ribcage () () ())
-                                            #(ribcage #(x) #(("m" top))
-                                              #("i"))
-                                            #(top-ribcage *top* #t)))
-                                       g2451)
-                                     (#%list
-                                       '#(syntax-object quote
-                                          ((top)
-                                            #(ribcage #(dummy tid id e1 e2)
-                                              #(("m" top) (top) (top) (top)
-                                                (top))
-                                              #("i" "i" "i" "i" "i"))
-                                            #(ribcage () () ())
-                                            #(ribcage #(x) #(("m" top))
-                                              #("i"))
-                                            #(top-ribcage *top* #t)))
-                                       g2455)))])
-                              g2452)
-                            (#%cons g2453 g2454))))])
-                   g2444)
-                 (#%syntax-error g2443))])
-           (#%$syntax-dispatch
-             g2443
-             '(any (any . each-any) any . each-any)))])
-       g2442)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object datum
-     ((top) #(ribcage #(datum) #((top)) #(datum))))
-  (case-lambda
-    [(g2456)
-     ((case-lambda
-        [(g2457)
-         ((case-lambda
-            [(g2458)
-             (if g2458
-                 (#%apply
-                   (case-lambda
-                     [(g2459 g2460)
-                      (#%list
-                        '#(syntax-object syntax-object->datum
-                           ((top)
-                             #(ribcage #(dummy x) #(("m" top) (top))
-                               #("i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #(("m" top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%list
-                          '#(syntax-object syntax
-                             ((top)
-                               #(ribcage #(dummy x) #(("m" top) (top))
-                                 #("i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #(("m" top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          g2460))])
-                   g2458)
-                 (#%syntax-error g2457))])
-           (#%$syntax-dispatch g2457 '(any any)))])
-       g2456)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object syntax-rules
-     ((top) #(ribcage #(syntax-rules) #((top)) #(syntax-rules))))
-  (case-lambda
-    [(g2461)
-     ((case-lambda
-        [(g2462)
-         ((case-lambda
-            [(g2463)
-             (begin
-               (set! g2462 g2463)
-               ((case-lambda
-                  [(g2464)
-                   ((case-lambda
-                      [(g2465)
-                       (if (if g2465
-                               (#%apply
-                                 (case-lambda
-                                   [(g2466 g2467 g2468)
-                                    ((top-level-value 'andmap)
-                                      (top-level-value 'identifier?)
-                                      g2467)])
-                                 g2465)
-                               '#f)
-                           (#%apply
-                             (case-lambda
-                               [(g2469 g2470 g2471)
-                                ((case-lambda
-                                   [(g2472)
-                                    ((case-lambda
-                                       [(g2473)
-                                        (if g2473
-                                            (#%apply
-                                              (case-lambda
-                                                [(g2474)
-                                                 (#%list
-                                                   '#(syntax-object lambda
-                                                      ((top)
-                                                        #(ribcage #(cl)
-                                                          #((top)) #("i"))
-                                                        #(ribcage #(_ k cl)
-                                                          #((top) (top)
-                                                            (top))
-                                                          #("i" "i" "i"))
-                                                        #(ribcage (clause)
-                                                          ((top)) ("i"))
-                                                        #(ribcage #(x)
-                                                          #((top)) #("i"))
-                                                        #(top-ribcage *top*
-                                                          #t)))
-                                                   '#(syntax-object (x)
-                                                      ((top)
-                                                        #(ribcage #(cl)
-                                                          #((top)) #("i"))
-                                                        #(ribcage #(_ k cl)
-                                                          #((top) (top)
-                                                            (top))
-                                                          #("i" "i" "i"))
-                                                        #(ribcage (clause)
-                                                          ((top)) ("i"))
-                                                        #(ribcage #(x)
-                                                          #((top)) #("i"))
-                                                        #(top-ribcage *top*
-                                                          #t)))
-                                                   (#%cons
-                                                     '#(syntax-object
-                                                        syntax-case
-                                                        ((top)
-                                                          #(ribcage #(cl)
-                                                            #((top))
-                                                            #("i"))
-                                                          #(ribcage
-                                                            #(_ k cl)
-                                                            #((top) (top)
-                                                              (top))
-                                                            #("i" "i" "i"))
-                                                          #(ribcage
-                                                            (clause)
-                                                            ((top)) ("i"))
-                                                          #(ribcage #(x)
-                                                            #((top))
-                                                            #("i"))
-                                                          #(top-ribcage
-                                                            *top* #t)))
-                                                     (#%cons
-                                                       '#(syntax-object x
-                                                          ((top)
-                                                            #(ribcage #(cl)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage
-                                                              #(_ k cl)
-                                                              #((top) (top)
-                                                                (top))
-                                                              #("i" "i"
-                                                                "i"))
-                                                            #(ribcage
-                                                              (clause)
-                                                              ((top))
-                                                              ("i"))
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%cons
-                                                         g2470
-                                                         g2474))))])
-                                              g2473)
-                                            (#%syntax-error g2472))])
-                                      (#%$syntax-dispatch
-                                        g2472
-                                        'each-any))])
-                                  ((top-level-value 'map) g2462 g2471))])
-                             g2465)
-                           (#%syntax-error g2464))])
-                     (#%$syntax-dispatch
-                       g2464
-                       '(any each-any . each-any)))])
-                 g2461))])
-           (case-lambda
-             [(g2475)
-              ((case-lambda
-                 [(g2476)
-                  ((case-lambda
-                     [(g2477)
-                      (if g2477
-                          (#%apply
-                            (case-lambda
-                              [(g2478 g2479 g2480)
-                               (#%list
-                                 (#%cons
-                                   '#(syntax-object dummy
-                                      ((top)
-                                        #(ribcage
-                                          #(keyword pattern template)
-                                          #((top) (top) (top))
-                                          #("i" "i" "i"))
-                                        #(ribcage () () ())
-                                        #(ribcage #(y) #((top)) #("i"))
-                                        #(ribcage (clause) ((top)) ("i"))
-                                        #(ribcage #(x) #((top)) #("i"))
-                                        #(top-ribcage *top* #t)))
-                                   g2479)
-                                 (#%list
-                                   '#(syntax-object syntax
-                                      ((top)
-                                        #(ribcage
-                                          #(keyword pattern template)
-                                          #((top) (top) (top))
-                                          #("i" "i" "i"))
-                                        #(ribcage () () ())
-                                        #(ribcage #(y) #((top)) #("i"))
-                                        #(ribcage (clause) ((top)) ("i"))
-                                        #(ribcage #(x) #((top)) #("i"))
-                                        #(top-ribcage *top* #t)))
-                                   g2480))])
-                            g2477)
-                          ((case-lambda
-                             [(g2481)
-                              (if g2481
-                                  (#%apply
-                                    (case-lambda
-                                      [(g2482 g2483 g2484 g2485)
-                                       (#%list
-                                         (#%cons
-                                           '#(syntax-object dummy
-                                              ((top)
-                                                #(ribcage
-                                                  #(keyword pattern fender
-                                                    template)
-                                                  #((top) (top) (top)
-                                                    (top))
-                                                  #("i" "i" "i" "i"))
-                                                #(ribcage () () ())
-                                                #(ribcage #(y) #((top))
-                                                  #("i"))
-                                                #(ribcage (clause) ((top))
-                                                  ("i"))
-                                                #(ribcage #(x) #((top))
-                                                  #("i"))
-                                                #(top-ribcage *top* #t)))
-                                           g2483)
-                                         g2484
-                                         (#%list
-                                           '#(syntax-object syntax
-                                              ((top)
-                                                #(ribcage
-                                                  #(keyword pattern fender
-                                                    template)
-                                                  #((top) (top) (top)
-                                                    (top))
-                                                  #("i" "i" "i" "i"))
-                                                #(ribcage () () ())
-                                                #(ribcage #(y) #((top))
-                                                  #("i"))
-                                                #(ribcage (clause) ((top))
-                                                  ("i"))
-                                                #(ribcage #(x) #((top))
-                                                  #("i"))
-                                                #(top-ribcage *top* #t)))
-                                           g2485))])
-                                    g2481)
-                                  ((case-lambda
-                                     [(g2486)
-                                      ((top-level-value 'syntax-error)
-                                        g2461)])
-                                    g2476))])
-                            (#%$syntax-dispatch
-                              g2476
-                              '((any . any) any any))))])
-                    (#%$syntax-dispatch g2476 '((any . any) any)))])
-                g2475)]))])
-       (void))])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object or ((top) #(ribcage #(or) #((top)) #(or))))
-  (case-lambda
-    [(g2487)
-     ((case-lambda
-        [(g2488)
-         ((case-lambda
-            [(g2489)
-             (if g2489
-                 (#%apply
-                   (case-lambda
-                     [(g2490)
-                      '#(syntax-object #f
-                         ((top)
-                           #(ribcage #(_) #((top)) #("i"))
-                           #(ribcage () () ())
-                           #(ribcage #(x) #((top)) #("i"))
-                           #(top-ribcage *top* #t)))])
-                   g2489)
-                 ((case-lambda
-                    [(g2491)
-                     (if g2491
-                         (#%apply
-                           (case-lambda [(g2492 g2493) g2493])
-                           g2491)
-                         ((case-lambda
-                            [(g2494)
-                             (if g2494
-                                 (#%apply
-                                   (case-lambda
-                                     [(g2495 g2496 g2497 g2498)
-                                      (#%list
-                                        '#(syntax-object let
-                                           ((top)
-                                             #(ribcage #(_ e1 e2 e3)
-                                               #((top) (top) (top) (top))
-                                               #("i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #((top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        (#%list
-                                          (#%list
-                                            '#(syntax-object t
-                                               ((top)
-                                                 #(ribcage #(_ e1 e2 e3)
-                                                   #((top) (top) (top)
-                                                     (top))
-                                                   #("i" "i" "i" "i"))
-                                                 #(ribcage () () ())
-                                                 #(ribcage #(x) #((top))
-                                                   #("i"))
-                                                 #(top-ribcage *top* #t)))
-                                            g2496))
-                                        (#%list
-                                          '#(syntax-object if
-                                             ((top)
-                                               #(ribcage #(_ e1 e2 e3)
-                                                 #((top) (top) (top) (top))
-                                                 #("i" "i" "i" "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))
-                                          '#(syntax-object t
-                                             ((top)
-                                               #(ribcage #(_ e1 e2 e3)
-                                                 #((top) (top) (top) (top))
-                                                 #("i" "i" "i" "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))
-                                          '#(syntax-object t
-                                             ((top)
-                                               #(ribcage #(_ e1 e2 e3)
-                                                 #((top) (top) (top) (top))
-                                                 #("i" "i" "i" "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))
-                                          (#%cons
-                                            '#(syntax-object or
-                                               ((top)
-                                                 #(ribcage #(_ e1 e2 e3)
-                                                   #((top) (top) (top)
-                                                     (top))
-                                                   #("i" "i" "i" "i"))
-                                                 #(ribcage () () ())
-                                                 #(ribcage #(x) #((top))
-                                                   #("i"))
-                                                 #(top-ribcage *top* #t)))
-                                            (#%cons g2497 g2498))))])
-                                   g2494)
-                                 (#%syntax-error g2488))])
-                           (#%$syntax-dispatch
-                             g2488
-                             '(any any any . each-any))))])
-                   (#%$syntax-dispatch g2488 '(any any))))])
-           (#%$syntax-dispatch g2488 '(any)))])
-       g2487)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object and
-     ((top) #(ribcage #(and) #((top)) #(and))))
-  (case-lambda
-    [(g2499)
-     ((case-lambda
-        [(g2500)
-         ((case-lambda
-            [(g2501)
-             (if g2501
-                 (#%apply
-                   (case-lambda
-                     [(g2502 g2503 g2504 g2505)
-                      (#%cons
-                        '#(syntax-object if
-                           ((top)
-                             #(ribcage #(_ e1 e2 e3)
-                               #((top) (top) (top) (top))
-                               #("i" "i" "i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #((top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%cons
-                          g2503
-                          (#%cons
-                            (#%cons
-                              '#(syntax-object and
-                                 ((top)
-                                   #(ribcage #(_ e1 e2 e3)
-                                     #((top) (top) (top) (top))
-                                     #("i" "i" "i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #((top)) #("i"))
-                                   #(top-ribcage *top* #t)))
-                              (#%cons g2504 g2505))
-                            '#(syntax-object (#f)
-                               ((top)
-                                 #(ribcage #(_ e1 e2 e3)
-                                   #((top) (top) (top) (top))
-                                   #("i" "i" "i" "i"))
-                                 #(ribcage () () ())
-                                 #(ribcage #(x) #((top)) #("i"))
-                                 #(top-ribcage *top* #t))))))])
-                   g2501)
-                 ((case-lambda
-                    [(g2506)
-                     (if g2506
-                         (#%apply
-                           (case-lambda [(g2507 g2508) g2508])
-                           g2506)
-                         ((case-lambda
-                            [(g2509)
-                             (if g2509
-                                 (#%apply
-                                   (case-lambda
-                                     [(g2510)
-                                      '#(syntax-object #t
-                                         ((top)
-                                           #(ribcage #(_) #((top)) #("i"))
-                                           #(ribcage () () ())
-                                           #(ribcage #(x) #((top)) #("i"))
-                                           #(top-ribcage *top* #t)))])
-                                   g2509)
-                                 (#%syntax-error g2500))])
-                           (#%$syntax-dispatch g2500 '(any))))])
-                   (#%$syntax-dispatch g2500 '(any any))))])
-           (#%$syntax-dispatch g2500 '(any any any . each-any)))])
-       g2499)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object let
-     ((top) #(ribcage #(let) #((top)) #(let))))
-  (case-lambda
-    [(g2511)
-     ((case-lambda
-        [(g2512)
-         ((case-lambda
-            [(g2513)
-             (if (if g2513
-                     (#%apply
-                       (case-lambda
-                         [(g2514 g2515 g2516 g2517 g2518)
-                          ((top-level-value 'andmap)
-                            (top-level-value 'identifier?)
-                            g2515)])
-                       g2513)
-                     '#f)
-                 (#%apply
-                   (case-lambda
-                     [(g2519 g2520 g2521 g2522 g2523)
-                      (#%cons
-                        (#%cons
-                          '#(syntax-object lambda
-                             ((top)
-                               #(ribcage #(_ x v e1 e2)
-                                 #((top) (top) (top) (top) (top))
-                                 #("i" "i" "i" "i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #((top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          (#%cons g2520 (#%cons g2522 g2523)))
-                        g2521)])
-                   g2513)
-                 ((case-lambda
-                    [(g2524)
-                     (if (if g2524
-                             (#%apply
-                               (case-lambda
-                                 [(g2525 g2526 g2527 g2528 g2529 g2530)
-                                  ((top-level-value 'andmap)
-                                    (top-level-value 'identifier?)
-                                    (#%cons g2526 g2527))])
-                               g2524)
-                             '#f)
-                         (#%apply
-                           (case-lambda
-                             [(g2531 g2532 g2533 g2534 g2535 g2536)
-                              (#%cons
-                                (#%list
-                                  '#(syntax-object letrec
-                                     ((top)
-                                       #(ribcage #(_ f x v e1 e2)
-                                         #((top) (top) (top) (top) (top)
-                                           (top))
-                                         #("i" "i" "i" "i" "i" "i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(x) #((top)) #("i"))
-                                       #(top-ribcage *top* #t)))
-                                  (#%list
-                                    (#%list
-                                      g2532
-                                      (#%cons
-                                        '#(syntax-object lambda
-                                           ((top)
-                                             #(ribcage #(_ f x v e1 e2)
-                                               #((top) (top) (top) (top)
-                                                 (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #((top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        (#%cons
-                                          g2533
-                                          (#%cons g2535 g2536)))))
-                                  g2532)
-                                g2534)])
-                           g2524)
-                         (#%syntax-error g2512))])
-                   (#%$syntax-dispatch
-                     g2512
-                     '(any any #(each (any any)) any . each-any))))])
-           (#%$syntax-dispatch
-             g2512
-             '(any #(each (any any)) any . each-any)))])
-       g2511)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object let*
-     ((top) #(ribcage #(let*) #((top)) #(let*))))
-  (case-lambda
-    [(g2537)
-     ((case-lambda
-        [(g2538)
-         ((case-lambda
-            [(g2539)
-             (if (if g2539
-                     (#%apply
-                       (case-lambda
-                         [(g2540 g2541 g2542 g2543 g2544)
-                          ((top-level-value 'andmap)
-                            (top-level-value 'identifier?)
-                            g2541)])
-                       g2539)
-                     '#f)
-                 (#%apply
-                   (case-lambda
-                     [(g2545 g2546 g2547 g2548 g2549)
-                      (((case-lambda
-                          [(g2550)
-                           ((case-lambda
-                              [(g2551) (begin (set! g2550 g2551) g2550)])
-                             (case-lambda
-                               [(g2552)
-                                (if ((top-level-value 'null?) g2552)
-                                    (#%cons
-                                      '#(syntax-object let
-                                         ((top) #(ribcage () () ())
-                                           #(ribcage #(bindings) #((top))
-                                             #("i"))
-                                           #(ribcage #(f) #((top)) #("i"))
-                                           #(ribcage #(let* x v e1 e2)
-                                             #((top) (top) (top) (top)
-                                               (top))
-                                             #("i" "i" "i" "i" "i"))
-                                           #(ribcage () () ())
-                                           #(ribcage #(x) #((top)) #("i"))
-                                           #(top-ribcage *top* #t)))
-                                      (#%cons '() (#%cons g2548 g2549)))
-                                    ((case-lambda
-                                       [(g2553)
-                                        ((case-lambda
-                                           [(g2554)
-                                            (if g2554
-                                                (#%apply
-                                                  (case-lambda
-                                                    [(g2555 g2556)
-                                                     (#%list
-                                                       '#(syntax-object let
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(body
-                                                                binding)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage
-                                                              #(bindings)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage #(f)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage
-                                                              #(let* x v e1
-                                                                e2)
-                                                              #((top) (top)
-                                                                (top) (top)
-                                                                (top))
-                                                              #("i" "i" "i"
-                                                                "i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%list g2556)
-                                                       g2555)])
-                                                  g2554)
-                                                (#%syntax-error g2553))])
-                                          (#%$syntax-dispatch
-                                            g2553
-                                            '(any any)))])
-                                      ((top-level-value 'list)
-                                        (g2550
-                                          ((top-level-value 'cdr) g2552))
-                                        ((top-level-value 'car)
-                                          g2552))))]))])
-                         (void))
-                        (#%map #%list g2546 g2547))])
-                   g2539)
-                 (#%syntax-error g2538))])
-           (#%$syntax-dispatch
-             g2538
-             '(any #(each (any any)) any . each-any)))])
-       g2537)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object cond
-     ((top) #(ribcage #(cond) #((top)) #(cond))))
-  (case-lambda
-    [(g2557)
-     ((case-lambda
-        [(g2558)
-         ((case-lambda
-            [(g2559)
-             (if g2559
-                 (#%apply
-                   (case-lambda
-                     [(g2560 g2561 g2562)
-                      (((case-lambda
-                          [(g2563)
-                           ((case-lambda
-                              [(g2564) (begin (set! g2563 g2564) g2563)])
-                             (case-lambda
-                               [(g2565 g2566)
-                                (if ((top-level-value 'null?) g2566)
-                                    ((case-lambda
-                                       [(g2567)
-                                        ((case-lambda
-                                           [(g2568)
-                                            (if g2568
-                                                (#%apply
-                                                  (case-lambda
-                                                    [(g2569 g2570)
-                                                     (#%cons
-                                                       '#(syntax-object
-                                                          begin
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(e1 e2)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage
-                                                              #(clause
-                                                                clauses)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage #(f)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage
-                                                              #(_ m1 m2)
-                                                              #((top) (top)
-                                                                (top))
-                                                              #("i" "i"
-                                                                "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%cons
-                                                         g2569
-                                                         g2570))])
-                                                  g2568)
-                                                ((case-lambda
-                                                   [(g2571)
-                                                    (if g2571
-                                                        (#%apply
-                                                          (case-lambda
-                                                            [(g2572)
-                                                             (#%cons
-                                                               '#(syntax-object
-                                                                  let
-                                                                  ((top)
-                                                                    #(ribcage
-                                                                      #(e0)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(ribcage
-                                                                      () ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      #(clause
-                                                                        clauses)
-                                                                      #((top)
-                                                                        (top))
-                                                                      #("i"
-                                                                        "i"))
-                                                                    #(ribcage
-                                                                      #(f)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(ribcage
-                                                                      #(_
-                                                                        m1
-                                                                        m2)
-                                                                      #((top)
-                                                                        (top)
-                                                                        (top))
-                                                                      #("i"
-                                                                        "i"
-                                                                        "i"))
-                                                                    #(ribcage
-                                                                      () ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      #(x)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(top-ribcage
-                                                                      *top*
-                                                                      #t)))
-                                                               (#%cons
-                                                                 (#%list
-                                                                   (#%list
-                                                                     '#(syntax-object
-                                                                        t
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(e0)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(clause
-                                                                              clauses)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(f)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            #(_
-                                                                              m1
-                                                                              m2)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(x)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t)))
-                                                                     g2572))
-                                                                 '#(syntax-object
-                                                                    ((if t
-                                                                         t))
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(e0)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))))])
-                                                          g2571)
-                                                        ((case-lambda
-                                                           [(g2573)
-                                                            (if g2573
-                                                                (#%apply
-                                                                  (case-lambda
-                                                                    [(g2574
-                                                                      g2575)
-                                                                     (#%list
-                                                                       '#(syntax-object
-                                                                          let
-                                                                          ((top)
-                                                                            #(ribcage
-                                                                              #(e0
-                                                                                e1)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(clause
-                                                                                clauses)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              #(f)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              #(_
-                                                                                m1
-                                                                                m2)
-                                                                              #((top)
-                                                                                (top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(x)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(top-ribcage
-                                                                              *top*
-                                                                              #t)))
-                                                                       (#%list
-                                                                         (#%list
-                                                                           '#(syntax-object
-                                                                              t
-                                                                              ((top)
-                                                                                #(ribcage
-                                                                                  #(e0
-                                                                                    e1)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(clause
-                                                                                    clauses)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(f)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  #(_
-                                                                                    m1
-                                                                                    m2)
-                                                                                  #((top)
-                                                                                    (top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(x)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(top-ribcage
-                                                                                  *top*
-                                                                                  #t)))
-                                                                           g2574))
-                                                                       (#%list
-                                                                         '#(syntax-object
-                                                                            if
-                                                                            ((top)
-                                                                              #(ribcage
-                                                                                #(e0
-                                                                                  e1)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(clause
-                                                                                  clauses)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(f)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                #(_
-                                                                                  m1
-                                                                                  m2)
-                                                                                #((top)
-                                                                                  (top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(x)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(top-ribcage
-                                                                                *top*
-                                                                                #t)))
-                                                                         '#(syntax-object
-                                                                            t
-                                                                            ((top)
-                                                                              #(ribcage
-                                                                                #(e0
-                                                                                  e1)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(clause
-                                                                                  clauses)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(f)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                #(_
-                                                                                  m1
-                                                                                  m2)
-                                                                                #((top)
-                                                                                  (top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(x)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(top-ribcage
-                                                                                *top*
-                                                                                #t)))
-                                                                         (#%cons
-                                                                           g2575
-                                                                           '#(syntax-object
-                                                                              (t)
-                                                                              ((top)
-                                                                                #(ribcage
-                                                                                  #(e0
-                                                                                    e1)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(clause
-                                                                                    clauses)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(f)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  #(_
-                                                                                    m1
-                                                                                    m2)
-                                                                                  #((top)
-                                                                                    (top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(x)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(top-ribcage
-                                                                                  *top*
-                                                                                  #t))))))])
-                                                                  g2573)
-                                                                ((case-lambda
-                                                                   [(g2576)
-                                                                    (if g2576
-                                                                        (#%apply
-                                                                          (case-lambda
-                                                                            [(g2577
-                                                                              g2578
-                                                                              g2579)
-                                                                             (#%list
-                                                                               '#(syntax-object
-                                                                                  if
-                                                                                  ((top)
-                                                                                    #(ribcage
-                                                                                      #(e0
-                                                                                        e1
-                                                                                        e2)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(clause
-                                                                                        clauses)
-                                                                                      #((top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      #(f)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(_
-                                                                                        m1
-                                                                                        m2)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(x)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(top-ribcage
-                                                                                      *top*
-                                                                                      #t)))
-                                                                               g2577
-                                                                               (#%cons
-                                                                                 '#(syntax-object
-                                                                                    begin
-                                                                                    ((top)
-                                                                                      #(ribcage
-                                                                                        #(e0
-                                                                                          e1
-                                                                                          e2)
-                                                                                        #((top)
-                                                                                          (top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        ()
-                                                                                        ()
-                                                                                        ())
-                                                                                      #(ribcage
-                                                                                        #(clause
-                                                                                          clauses)
-                                                                                        #((top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        #(f)
-                                                                                        #((top))
-                                                                                        #("i"))
-                                                                                      #(ribcage
-                                                                                        #(_
-                                                                                          m1
-                                                                                          m2)
-                                                                                        #((top)
-                                                                                          (top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        ()
-                                                                                        ()
-                                                                                        ())
-                                                                                      #(ribcage
-                                                                                        #(x)
-                                                                                        #((top))
-                                                                                        #("i"))
-                                                                                      #(top-ribcage
-                                                                                        *top*
-                                                                                        #t)))
-                                                                                 (#%cons
-                                                                                   g2578
-                                                                                   g2579)))])
-                                                                          g2576)
-                                                                        ((case-lambda
-                                                                           [(g2580)
-                                                                            ((top-level-value
-                                                                               'syntax-error)
-                                                                              g2557)])
-                                                                          g2567))])
-                                                                  (#%$syntax-dispatch
-                                                                    g2567
-                                                                    '(any any
-                                                                          .
-                                                                          each-any))))])
-                                                          (#%$syntax-dispatch
-                                                            g2567
-                                                            '(any #(free-id
-                                                                    #(syntax-object
-                                                                      =>
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t))))
-                                                                  any))))])
-                                                  (#%$syntax-dispatch
-                                                    g2567
-                                                    '(any))))])
-                                          (#%$syntax-dispatch
-                                            g2567
-                                            '(#(free-id
-                                                #(syntax-object else
-                                                  ((top)
-                                                    #(ribcage () () ())
-                                                    #(ribcage
-                                                      #(clause clauses)
-                                                      #((top) (top))
-                                                      #("i" "i"))
-                                                    #(ribcage #(f) #((top))
-                                                      #("i"))
-                                                    #(ribcage #(_ m1 m2)
-                                                      #((top) (top) (top))
-                                                      #("i" "i" "i"))
-                                                    #(ribcage () () ())
-                                                    #(ribcage #(x) #((top))
-                                                      #("i"))
-                                                    #(top-ribcage *top*
-                                                      #t))))
-                                               any
-                                               .
-                                               each-any)))])
-                                      g2565)
-                                    ((case-lambda
-                                       [(g2581)
-                                        ((case-lambda
-                                           [(g2582)
-                                            ((case-lambda
-                                               [(g2583)
-                                                ((case-lambda
-                                                   [(g2584)
-                                                    (if g2584
-                                                        (#%apply
-                                                          (case-lambda
-                                                            [(g2585)
-                                                             (#%list
-                                                               '#(syntax-object
-                                                                  let
-                                                                  ((top)
-                                                                    #(ribcage
-                                                                      #(e0)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(ribcage
-                                                                      #(rest)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(ribcage
-                                                                      () ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      #(clause
-                                                                        clauses)
-                                                                      #((top)
-                                                                        (top))
-                                                                      #("i"
-                                                                        "i"))
-                                                                    #(ribcage
-                                                                      #(f)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(ribcage
-                                                                      #(_
-                                                                        m1
-                                                                        m2)
-                                                                      #((top)
-                                                                        (top)
-                                                                        (top))
-                                                                      #("i"
-                                                                        "i"
-                                                                        "i"))
-                                                                    #(ribcage
-                                                                      () ()
-                                                                      ())
-                                                                    #(ribcage
-                                                                      #(x)
-                                                                      #((top))
-                                                                      #("i"))
-                                                                    #(top-ribcage
-                                                                      *top*
-                                                                      #t)))
-                                                               (#%list
-                                                                 (#%list
-                                                                   '#(syntax-object
-                                                                      t
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(e0)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(rest)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   g2585))
-                                                               (#%list
-                                                                 '#(syntax-object
-                                                                    if
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(e0)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(rest)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 '#(syntax-object
-                                                                    t
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(e0)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(rest)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 '#(syntax-object
-                                                                    t
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(e0)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(rest)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 g2582))])
-                                                          g2584)
-                                                        ((case-lambda
-                                                           [(g2586)
-                                                            (if g2586
-                                                                (#%apply
-                                                                  (case-lambda
-                                                                    [(g2587
-                                                                      g2588)
-                                                                     (#%list
-                                                                       '#(syntax-object
-                                                                          let
-                                                                          ((top)
-                                                                            #(ribcage
-                                                                              #(e0
-                                                                                e1)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              #(rest)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(clause
-                                                                                clauses)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              #(f)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              #(_
-                                                                                m1
-                                                                                m2)
-                                                                              #((top)
-                                                                                (top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(x)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(top-ribcage
-                                                                              *top*
-                                                                              #t)))
-                                                                       (#%list
-                                                                         (#%list
-                                                                           '#(syntax-object
-                                                                              t
-                                                                              ((top)
-                                                                                #(ribcage
-                                                                                  #(e0
-                                                                                    e1)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(rest)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(clause
-                                                                                    clauses)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(f)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  #(_
-                                                                                    m1
-                                                                                    m2)
-                                                                                  #((top)
-                                                                                    (top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(x)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(top-ribcage
-                                                                                  *top*
-                                                                                  #t)))
-                                                                           g2587))
-                                                                       (#%list
-                                                                         '#(syntax-object
-                                                                            if
-                                                                            ((top)
-                                                                              #(ribcage
-                                                                                #(e0
-                                                                                  e1)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(rest)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(clause
-                                                                                  clauses)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(f)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                #(_
-                                                                                  m1
-                                                                                  m2)
-                                                                                #((top)
-                                                                                  (top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(x)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(top-ribcage
-                                                                                *top*
-                                                                                #t)))
-                                                                         '#(syntax-object
-                                                                            t
-                                                                            ((top)
-                                                                              #(ribcage
-                                                                                #(e0
-                                                                                  e1)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(rest)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(clause
-                                                                                  clauses)
-                                                                                #((top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                #(f)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(ribcage
-                                                                                #(_
-                                                                                  m1
-                                                                                  m2)
-                                                                                #((top)
-                                                                                  (top)
-                                                                                  (top))
-                                                                                #("i"
-                                                                                  "i"
-                                                                                  "i"))
-                                                                              #(ribcage
-                                                                                ()
-                                                                                ()
-                                                                                ())
-                                                                              #(ribcage
-                                                                                #(x)
-                                                                                #((top))
-                                                                                #("i"))
-                                                                              #(top-ribcage
-                                                                                *top*
-                                                                                #t)))
-                                                                         (#%cons
-                                                                           g2588
-                                                                           '#(syntax-object
-                                                                              (t)
-                                                                              ((top)
-                                                                                #(ribcage
-                                                                                  #(e0
-                                                                                    e1)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(rest)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(clause
-                                                                                    clauses)
-                                                                                  #((top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  #(f)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(ribcage
-                                                                                  #(_
-                                                                                    m1
-                                                                                    m2)
-                                                                                  #((top)
-                                                                                    (top)
-                                                                                    (top))
-                                                                                  #("i"
-                                                                                    "i"
-                                                                                    "i"))
-                                                                                #(ribcage
-                                                                                  ()
-                                                                                  ()
-                                                                                  ())
-                                                                                #(ribcage
-                                                                                  #(x)
-                                                                                  #((top))
-                                                                                  #("i"))
-                                                                                #(top-ribcage
-                                                                                  *top*
-                                                                                  #t))))
-                                                                         g2582))])
-                                                                  g2586)
-                                                                ((case-lambda
-                                                                   [(g2589)
-                                                                    (if g2589
-                                                                        (#%apply
-                                                                          (case-lambda
-                                                                            [(g2590
-                                                                              g2591
-                                                                              g2592)
-                                                                             (#%list
-                                                                               '#(syntax-object
-                                                                                  if
-                                                                                  ((top)
-                                                                                    #(ribcage
-                                                                                      #(e0
-                                                                                        e1
-                                                                                        e2)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      #(rest)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(clause
-                                                                                        clauses)
-                                                                                      #((top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      #(f)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(_
-                                                                                        m1
-                                                                                        m2)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(x)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(top-ribcage
-                                                                                      *top*
-                                                                                      #t)))
-                                                                               g2590
-                                                                               (#%cons
-                                                                                 '#(syntax-object
-                                                                                    begin
-                                                                                    ((top)
-                                                                                      #(ribcage
-                                                                                        #(e0
-                                                                                          e1
-                                                                                          e2)
-                                                                                        #((top)
-                                                                                          (top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        #(rest)
-                                                                                        #((top))
-                                                                                        #("i"))
-                                                                                      #(ribcage
-                                                                                        ()
-                                                                                        ()
-                                                                                        ())
-                                                                                      #(ribcage
-                                                                                        #(clause
-                                                                                          clauses)
-                                                                                        #((top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        #(f)
-                                                                                        #((top))
-                                                                                        #("i"))
-                                                                                      #(ribcage
-                                                                                        #(_
-                                                                                          m1
-                                                                                          m2)
-                                                                                        #((top)
-                                                                                          (top)
-                                                                                          (top))
-                                                                                        #("i"
-                                                                                          "i"
-                                                                                          "i"))
-                                                                                      #(ribcage
-                                                                                        ()
-                                                                                        ()
-                                                                                        ())
-                                                                                      #(ribcage
-                                                                                        #(x)
-                                                                                        #((top))
-                                                                                        #("i"))
-                                                                                      #(top-ribcage
-                                                                                        *top*
-                                                                                        #t)))
-                                                                                 (#%cons
-                                                                                   g2591
-                                                                                   g2592))
-                                                                               g2582)])
-                                                                          g2589)
-                                                                        ((case-lambda
-                                                                           [(g2593)
-                                                                            ((top-level-value
-                                                                               'syntax-error)
-                                                                              g2557)])
-                                                                          g2583))])
-                                                                  (#%$syntax-dispatch
-                                                                    g2583
-                                                                    '(any any
-                                                                          .
-                                                                          each-any))))])
-                                                          (#%$syntax-dispatch
-                                                            g2583
-                                                            '(any #(free-id
-                                                                    #(syntax-object
-                                                                      =>
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(rest)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t))))
-                                                                  any))))])
-                                                  (#%$syntax-dispatch
-                                                    g2583
-                                                    '(any)))])
-                                              g2565)])
-                                          g2581)])
-                                      (g2563
-                                        ((top-level-value 'car) g2566)
-                                        ((top-level-value 'cdr)
-                                          g2566))))]))])
-                         (void))
-                        g2561
-                        g2562)])
-                   g2559)
-                 (#%syntax-error g2558))])
-           (#%$syntax-dispatch g2558 '(any any . each-any)))])
-       g2557)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object do ((top) #(ribcage #(do) #((top)) #(do))))
-  (case-lambda
-    [(g2594)
-     ((case-lambda
-        [(g2595)
-         ((case-lambda
-            [(g2596)
-             (if g2596
-                 (#%apply
-                   (case-lambda
-                     [(g2597 g2598 g2599 g2600 g2601 g2602 g2603)
-                      ((case-lambda
-                         [(g2604)
-                          ((case-lambda
-                             [(g2605)
-                              (if g2605
-                                  (#%apply
-                                    (case-lambda
-                                      [(g2606)
-                                       ((case-lambda
-                                          [(g2607)
-                                           ((case-lambda
-                                              [(g2608)
-                                               (if g2608
-                                                   (#%apply
-                                                     (case-lambda
-                                                       [()
-                                                        (#%list
-                                                          '#(syntax-object
-                                                             let
-                                                             ((top)
-                                                               #(ribcage
-                                                                 #(step)
-                                                                 #((top))
-                                                                 #("i"))
-                                                               #(ribcage
-                                                                 #(_ var
-                                                                   init
-                                                                   step e0
-                                                                   e1 c)
-                                                                 #((top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top))
-                                                                 #("i" "i"
-                                                                   "i" "i"
-                                                                   "i" "i"
-                                                                   "i"))
-                                                               #(ribcage ()
-                                                                 () ())
-                                                               #(ribcage
-                                                                 #(orig-x)
-                                                                 #((top))
-                                                                 #("i"))
-                                                               #(top-ribcage
-                                                                 *top*
-                                                                 #t)))
-                                                          '#(syntax-object
-                                                             do
-                                                             ((top)
-                                                               #(ribcage
-                                                                 #(step)
-                                                                 #((top))
-                                                                 #("i"))
-                                                               #(ribcage
-                                                                 #(_ var
-                                                                   init
-                                                                   step e0
-                                                                   e1 c)
-                                                                 #((top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top))
-                                                                 #("i" "i"
-                                                                   "i" "i"
-                                                                   "i" "i"
-                                                                   "i"))
-                                                               #(ribcage ()
-                                                                 () ())
-                                                               #(ribcage
-                                                                 #(orig-x)
-                                                                 #((top))
-                                                                 #("i"))
-                                                               #(top-ribcage
-                                                                 *top*
-                                                                 #t)))
-                                                          (#%map
-                                                            #%list
-                                                            g2598
-                                                            g2599)
-                                                          (#%list
-                                                            '#(syntax-object
-                                                               if
-                                                               ((top)
-                                                                 #(ribcage
-                                                                   #(step)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(ribcage
-                                                                   #(_ var
-                                                                     init
-                                                                     step
-                                                                     e0 e1
-                                                                     c)
-                                                                   #((top)
-                                                                     (top)
-                                                                     (top)
-                                                                     (top)
-                                                                     (top)
-                                                                     (top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"
-                                                                     "i"
-                                                                     "i"
-                                                                     "i"
-                                                                     "i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   () ()
-                                                                   ())
-                                                                 #(ribcage
-                                                                   #(orig-x)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(top-ribcage
-                                                                   *top*
-                                                                   #t)))
-                                                            (#%list
-                                                              '#(syntax-object
-                                                                 not
-                                                                 ((top)
-                                                                   #(ribcage
-                                                                     #(step)
-                                                                     #((top))
-                                                                     #("i"))
-                                                                   #(ribcage
-                                                                     #(_
-                                                                       var
-                                                                       init
-                                                                       step
-                                                                       e0
-                                                                       e1
-                                                                       c)
-                                                                     #((top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top))
-                                                                     #("i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"))
-                                                                   #(ribcage
-                                                                     () ()
-                                                                     ())
-                                                                   #(ribcage
-                                                                     #(orig-x)
-                                                                     #((top))
-                                                                     #("i"))
-                                                                   #(top-ribcage
-                                                                     *top*
-                                                                     #t)))
-                                                              g2601)
-                                                            (#%cons
-                                                              '#(syntax-object
-                                                                 begin
-                                                                 ((top)
-                                                                   #(ribcage
-                                                                     #(step)
-                                                                     #((top))
-                                                                     #("i"))
-                                                                   #(ribcage
-                                                                     #(_
-                                                                       var
-                                                                       init
-                                                                       step
-                                                                       e0
-                                                                       e1
-                                                                       c)
-                                                                     #((top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top)
-                                                                       (top))
-                                                                     #("i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"
-                                                                       "i"))
-                                                                   #(ribcage
-                                                                     () ()
-                                                                     ())
-                                                                   #(ribcage
-                                                                     #(orig-x)
-                                                                     #((top))
-                                                                     #("i"))
-                                                                   #(top-ribcage
-                                                                     *top*
-                                                                     #t)))
-                                                              (#%append
-                                                                g2603
-                                                                (#%list
-                                                                  (#%cons
-                                                                    '#(syntax-object
-                                                                       do
-                                                                       ((top)
-                                                                         #(ribcage
-                                                                           #(step)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(ribcage
-                                                                           #(_
-                                                                             var
-                                                                             init
-                                                                             step
-                                                                             e0
-                                                                             e1
-                                                                             c)
-                                                                           #((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           ()
-                                                                           ()
-                                                                           ())
-                                                                         #(ribcage
-                                                                           #(orig-x)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(top-ribcage
-                                                                           *top*
-                                                                           #t)))
-                                                                    g2606))))))])
-                                                     g2608)
-                                                   ((case-lambda
-                                                      [(g2609)
-                                                       (if g2609
-                                                           (#%apply
-                                                             (case-lambda
-                                                               [(g2610
-                                                                 g2611)
-                                                                (#%list
-                                                                  '#(syntax-object
-                                                                     let
-                                                                     ((top)
-                                                                       #(ribcage
-                                                                         #(e1
-                                                                           e2)
-                                                                         #((top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         #(step)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(ribcage
-                                                                         #(_
-                                                                           var
-                                                                           init
-                                                                           step
-                                                                           e0
-                                                                           e1
-                                                                           c)
-                                                                         #((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         ()
-                                                                         ()
-                                                                         ())
-                                                                       #(ribcage
-                                                                         #(orig-x)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(top-ribcage
-                                                                         *top*
-                                                                         #t)))
-                                                                  '#(syntax-object
-                                                                     do
-                                                                     ((top)
-                                                                       #(ribcage
-                                                                         #(e1
-                                                                           e2)
-                                                                         #((top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         #(step)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(ribcage
-                                                                         #(_
-                                                                           var
-                                                                           init
-                                                                           step
-                                                                           e0
-                                                                           e1
-                                                                           c)
-                                                                         #((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         ()
-                                                                         ()
-                                                                         ())
-                                                                       #(ribcage
-                                                                         #(orig-x)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(top-ribcage
-                                                                         *top*
-                                                                         #t)))
-                                                                  (#%map
-                                                                    #%list
-                                                                    g2598
-                                                                    g2599)
-                                                                  (#%list
-                                                                    '#(syntax-object
-                                                                       if
-                                                                       ((top)
-                                                                         #(ribcage
-                                                                           #(e1
-                                                                             e2)
-                                                                           #((top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           #(step)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(ribcage
-                                                                           #(_
-                                                                             var
-                                                                             init
-                                                                             step
-                                                                             e0
-                                                                             e1
-                                                                             c)
-                                                                           #((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           ()
-                                                                           ()
-                                                                           ())
-                                                                         #(ribcage
-                                                                           #(orig-x)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(top-ribcage
-                                                                           *top*
-                                                                           #t)))
-                                                                    g2601
-                                                                    (#%cons
-                                                                      '#(syntax-object
-                                                                         begin
-                                                                         ((top)
-                                                                           #(ribcage
-                                                                             #(e1
-                                                                               e2)
-                                                                             #((top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             #(step)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(ribcage
-                                                                             #(_
-                                                                               var
-                                                                               init
-                                                                               step
-                                                                               e0
-                                                                               e1
-                                                                               c)
-                                                                             #((top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             ()
-                                                                             ()
-                                                                             ())
-                                                                           #(ribcage
-                                                                             #(orig-x)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(top-ribcage
-                                                                             *top*
-                                                                             #t)))
-                                                                      (#%cons
-                                                                        g2610
-                                                                        g2611))
-                                                                    (#%cons
-                                                                      '#(syntax-object
-                                                                         begin
-                                                                         ((top)
-                                                                           #(ribcage
-                                                                             #(e1
-                                                                               e2)
-                                                                             #((top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             #(step)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(ribcage
-                                                                             #(_
-                                                                               var
-                                                                               init
-                                                                               step
-                                                                               e0
-                                                                               e1
-                                                                               c)
-                                                                             #((top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             ()
-                                                                             ()
-                                                                             ())
-                                                                           #(ribcage
-                                                                             #(orig-x)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(top-ribcage
-                                                                             *top*
-                                                                             #t)))
-                                                                      (#%append
-                                                                        g2603
-                                                                        (#%list
-                                                                          (#%cons
-                                                                            '#(syntax-object
-                                                                               do
-                                                                               ((top)
-                                                                                 #(ribcage
-                                                                                   #(e1
-                                                                                     e2)
-                                                                                   #((top)
-                                                                                     (top))
-                                                                                   #("i"
-                                                                                     "i"))
-                                                                                 #(ribcage
-                                                                                   #(step)
-                                                                                   #((top))
-                                                                                   #("i"))
-                                                                                 #(ribcage
-                                                                                   #(_
-                                                                                     var
-                                                                                     init
-                                                                                     step
-                                                                                     e0
-                                                                                     e1
-                                                                                     c)
-                                                                                   #((top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top)
-                                                                                     (top))
-                                                                                   #("i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"
-                                                                                     "i"))
-                                                                                 #(ribcage
-                                                                                   ()
-                                                                                   ()
-                                                                                   ())
-                                                                                 #(ribcage
-                                                                                   #(orig-x)
-                                                                                   #((top))
-                                                                                   #("i"))
-                                                                                 #(top-ribcage
-                                                                                   *top*
-                                                                                   #t)))
-                                                                            g2606))))))])
-                                                             g2609)
-                                                           (#%syntax-error
-                                                             g2607))])
-                                                     (#%$syntax-dispatch
-                                                       g2607
-                                                       '(any .
-                                                             each-any))))])
-                                             (#%$syntax-dispatch
-                                               g2607
-                                               '()))])
-                                         g2602)])
-                                    g2605)
-                                  (#%syntax-error g2604))])
-                            (#%$syntax-dispatch g2604 'each-any))])
-                        ((top-level-value 'map)
-                          (case-lambda
-                            [(g2612 g2613)
-                             ((case-lambda
-                                [(g2614)
-                                 ((case-lambda
-                                    [(g2615)
-                                     (if g2615
-                                         (#%apply
-                                           (case-lambda [() g2612])
-                                           g2615)
-                                         ((case-lambda
-                                            [(g2616)
-                                             (if g2616
-                                                 (#%apply
-                                                   (case-lambda
-                                                     [(g2617) g2617])
-                                                   g2616)
-                                                 ((case-lambda
-                                                    [(g2618)
-                                                     ((top-level-value
-                                                        'syntax-error)
-                                                       g2594)])
-                                                   g2614))])
-                                           (#%$syntax-dispatch
-                                             g2614
-                                             '(any))))])
-                                   (#%$syntax-dispatch g2614 '()))])
-                               g2613)])
-                          g2598
-                          g2600))])
-                   g2596)
-                 (#%syntax-error g2595))])
-           (#%$syntax-dispatch
-             g2595
-             '(any #(each (any any . any))
-                   (any . each-any)
-                   .
-                   each-any)))])
-       g2594)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object quasiquote
-     ((top) #(ribcage #(quasiquote) #((top)) #(quasiquote))))
-  ((case-lambda
-     [(g2619 g2620 g2621 g2622 g2623 g2624 g2625 g2626 g2627
-       g2628)
-      ((case-lambda
-         [(g2629 g2630 g2631 g2632 g2633 g2634 g2635 g2636 g2637
-           g2638)
-          (begin
-            (set! g2619 g2629)
-            (set! g2620 g2630)
-            (set! g2621 g2631)
-            (set! g2622 g2632)
-            (set! g2623 g2633)
-            (set! g2624 g2634)
-            (set! g2625 g2635)
-            (set! g2626 g2636)
-            (set! g2627 g2637)
-            (set! g2628 g2638)
-            (case-lambda
-              [(g2639)
-               ((case-lambda
-                  [(g2640)
-                   ((case-lambda
-                      [(g2641)
-                       (if g2641
-                           (#%apply
-                             (case-lambda [(g2642 g2643) (g2628 g2643 '0)])
-                             g2641)
-                           (#%syntax-error g2640))])
-                     (#%$syntax-dispatch g2640 '(any any)))])
-                 g2639)]))])
-        (case-lambda
-          [(g2644)
-           (if ((top-level-value 'identifier?) g2644)
-               ((top-level-value 'free-identifier=?)
-                 g2644
-                 '#(syntax-object quote
-                    ((top)
-                      #(ribcage () () ())
-                      #(ribcage #(x) #((top)) #("i"))
-                      #(ribcage
-                        #(isquote? islist? iscons? quote-nil? quasilist*
-                          quasicons quasiappend quasivector vquasi quasi)
-                        #((top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top))
-                        #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"))
-                      #(top-ribcage *top* #t))))
-               '#f)])
-        (case-lambda
-          [(g2645)
-           (if ((top-level-value 'identifier?) g2645)
-               ((top-level-value 'free-identifier=?)
-                 g2645
-                 '#(syntax-object list
-                    ((top)
-                      #(ribcage () () ())
-                      #(ribcage #(x) #((top)) #("i"))
-                      #(ribcage
-                        #(isquote? islist? iscons? quote-nil? quasilist*
-                          quasicons quasiappend quasivector vquasi quasi)
-                        #((top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top))
-                        #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"))
-                      #(top-ribcage *top* #t))))
-               '#f)])
-        (case-lambda
-          [(g2646)
-           (if ((top-level-value 'identifier?) g2646)
-               ((top-level-value 'free-identifier=?)
-                 g2646
-                 '#(syntax-object cons
-                    ((top)
-                      #(ribcage () () ())
-                      #(ribcage #(x) #((top)) #("i"))
-                      #(ribcage
-                        #(isquote? islist? iscons? quote-nil? quasilist*
-                          quasicons quasiappend quasivector vquasi quasi)
-                        #((top) (top) (top) (top) (top) (top) (top) (top)
-                          (top) (top))
-                        #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"))
-                      #(top-ribcage *top* #t))))
-               '#f)])
-        (case-lambda
-          [(g2647)
-           ((case-lambda
-              [(g2648)
-               ((case-lambda
-                  [(g2649)
-                   (if g2649
-                       (#%apply
-                         (case-lambda [(g2650) (g2619 g2650)])
-                         g2649)
-                       ((case-lambda [(g2651) '#f]) g2648))])
-                 (#%$syntax-dispatch g2648 '(any ())))])
-             g2647)])
-        (case-lambda
-          [(g2652 g2653)
-           (((case-lambda
-               [(g2654)
-                ((case-lambda [(g2655) (begin (set! g2654 g2655) g2654)])
-                  (case-lambda
-                    [(g2656)
-                     (if ((top-level-value 'null?) g2656)
-                         g2653
-                         (g2624
-                           ((top-level-value 'car) g2656)
-                           (g2654 ((top-level-value 'cdr) g2656))))]))])
-              (void))
-             g2652)])
-        (case-lambda
-          [(g2657 g2658)
-           ((case-lambda
-              [(g2659)
-               ((case-lambda
-                  [(g2660)
-                   (if g2660
-                       (#%apply
-                         (case-lambda
-                           [(g2661 g2662)
-                            ((case-lambda
-                               [(g2663)
-                                ((case-lambda
-                                   [(g2664)
-                                    (if (if g2664
-                                            (#%apply
-                                              (case-lambda
-                                                [(g2665 g2666)
-                                                 (g2619 g2665)])
-                                              g2664)
-                                            '#f)
-                                        (#%apply
-                                          (case-lambda
-                                            [(g2667 g2668)
-                                             ((case-lambda
-                                                [(g2669)
-                                                 ((case-lambda
-                                                    [(g2670)
-                                                     (if (if g2670
-                                                             (#%apply
-                                                               (case-lambda
-                                                                 [(g2671
-                                                                   g2672)
-                                                                  (g2619
-                                                                    g2671)])
-                                                               g2670)
-                                                             '#f)
-                                                         (#%apply
-                                                           (case-lambda
-                                                             [(g2673 g2674)
-                                                              (#%list
-                                                                '#(syntax-object
-                                                                   quote
-                                                                   ((top)
-                                                                     #(ribcage
-                                                                       #(quote?
-                                                                         dx)
-                                                                       #((top)
-                                                                         (top))
-                                                                       #("i"
-                                                                         "i"))
-                                                                     #(ribcage
-                                                                       #(quote?
-                                                                         dy)
-                                                                       #((top)
-                                                                         (top))
-                                                                       #("i"
-                                                                         "i"))
-                                                                     #(ribcage
-                                                                       #(x
-                                                                         y)
-                                                                       #((top)
-                                                                         (top))
-                                                                       #("i"
-                                                                         "i"))
-                                                                     #(ribcage
-                                                                       ()
-                                                                       ()
-                                                                       ())
-                                                                     #(ribcage
-                                                                       #(x
-                                                                         y)
-                                                                       #((top)
-                                                                         (top))
-                                                                       #("i"
-                                                                         "i"))
-                                                                     #(ribcage
-                                                                       #(isquote?
-                                                                         islist?
-                                                                         iscons?
-                                                                         quote-nil?
-                                                                         quasilist*
-                                                                         quasicons
-                                                                         quasiappend
-                                                                         quasivector
-                                                                         vquasi
-                                                                         quasi)
-                                                                       #((top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top)
-                                                                         (top))
-                                                                       #("i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"
-                                                                         "i"))
-                                                                     #(top-ribcage
-                                                                       *top*
-                                                                       #t)))
-                                                                (#%cons
-                                                                  g2674
-                                                                  g2668))])
-                                                           g2670)
-                                                         ((case-lambda
-                                                            [(g2675)
-                                                             (if ((top-level-value
-                                                                    'null?)
-                                                                   g2668)
-                                                                 (#%list
-                                                                   '#(syntax-object
-                                                                      list
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(_)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(quote?
-                                                                            dy)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(x
-                                                                            y)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x
-                                                                            y)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(isquote?
-                                                                            islist?
-                                                                            iscons?
-                                                                            quote-nil?
-                                                                            quasilist*
-                                                                            quasicons
-                                                                            quasiappend
-                                                                            quasivector
-                                                                            vquasi
-                                                                            quasi)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   g2661)
-                                                                 (#%list
-                                                                   '#(syntax-object
-                                                                      cons
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(_)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(quote?
-                                                                            dy)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(x
-                                                                            y)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x
-                                                                            y)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(isquote?
-                                                                            islist?
-                                                                            iscons?
-                                                                            quote-nil?
-                                                                            quasilist*
-                                                                            quasicons
-                                                                            quasiappend
-                                                                            quasivector
-                                                                            vquasi
-                                                                            quasi)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   g2661
-                                                                   g2662))])
-                                                           g2669))])
-                                                   (#%$syntax-dispatch
-                                                     g2669
-                                                     '(any any)))])
-                                               g2661)])
-                                          g2664)
-                                        ((case-lambda
-                                           [(g2676)
-                                            (if (if g2676
-                                                    (#%apply
-                                                      (case-lambda
-                                                        [(g2677 g2678)
-                                                         (g2620 g2677)])
-                                                      g2676)
-                                                    '#f)
-                                                (#%apply
-                                                  (case-lambda
-                                                    [(g2679 g2680)
-                                                     (#%cons
-                                                       '#(syntax-object
-                                                          list
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(listp
-                                                                stuff)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage
-                                                              #(x y)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage
-                                                              #(x y)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage
-                                                              #(isquote?
-                                                                islist?
-                                                                iscons?
-                                                                quote-nil?
-                                                                quasilist*
-                                                                quasicons
-                                                                quasiappend
-                                                                quasivector
-                                                                vquasi
-                                                                quasi)
-                                                              #((top) (top)
-                                                                (top) (top)
-                                                                (top) (top)
-                                                                (top) (top)
-                                                                (top)
-                                                                (top))
-                                                              #("i" "i" "i"
-                                                                "i" "i" "i"
-                                                                "i" "i" "i"
-                                                                "i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%cons
-                                                         g2661
-                                                         g2680))])
-                                                  g2676)
-                                                ((case-lambda
-                                                   [(g2681)
-                                                    (#%list
-                                                      '#(syntax-object cons
-                                                         ((top)
-                                                           #(ribcage
-                                                             #(else)
-                                                             #((top))
-                                                             #("i"))
-                                                           #(ribcage #(x y)
-                                                             #((top) (top))
-                                                             #("i" "i"))
-                                                           #(ribcage () ()
-                                                             ())
-                                                           #(ribcage #(x y)
-                                                             #((top) (top))
-                                                             #("i" "i"))
-                                                           #(ribcage
-                                                             #(isquote?
-                                                               islist?
-                                                               iscons?
-                                                               quote-nil?
-                                                               quasilist*
-                                                               quasicons
-                                                               quasiappend
-                                                               quasivector
-                                                               vquasi
-                                                               quasi)
-                                                             #((top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top))
-                                                             #("i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i"))
-                                                           #(top-ribcage
-                                                             *top* #t)))
-                                                      g2661
-                                                      g2662)])
-                                                  g2663))])
-                                          (#%$syntax-dispatch
-                                            g2663
-                                            '(any . any))))])
-                                  (#%$syntax-dispatch g2663 '(any any)))])
-                              g2662)])
-                         g2660)
-                       (#%syntax-error g2659))])
-                 (#%$syntax-dispatch g2659 '(any any)))])
-             ((top-level-value 'list) g2657 g2658))])
-        (case-lambda
-          [(g2682 g2683)
-           ((case-lambda
-              [(g2684)
-               (if ((top-level-value 'null?) g2684)
-                   '#(syntax-object '()
-                      ((top) #(ribcage () () ())
-                        #(ribcage #(ls) #((top)) #("i"))
-                        #(ribcage () () ())
-                        #(ribcage #(x y) #((top) (top)) #("i" "i"))
-                        #(ribcage
-                          #(isquote? islist? iscons? quote-nil? quasilist*
-                            quasicons quasiappend quasivector vquasi quasi)
-                          #((top) (top) (top) (top) (top) (top) (top) (top)
-                            (top) (top))
-                          #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"))
-                        #(top-ribcage *top* #t)))
-                   (if ((top-level-value 'null?)
-                         ((top-level-value 'cdr) g2684))
-                       ((top-level-value 'car) g2684)
-                       ((case-lambda
-                          [(g2685)
-                           ((case-lambda
-                              [(g2686)
-                               (if g2686
-                                   (#%apply
-                                     (case-lambda
-                                       [(g2687)
-                                        (#%cons
-                                          '#(syntax-object append
-                                             ((top)
-                                               #(ribcage #(p) #((top))
-                                                 #("i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(ls) #((top))
-                                                 #("i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x y)
-                                                 #((top) (top)) #("i" "i"))
-                                               #(ribcage
-                                                 #(isquote? islist? iscons?
-                                                   quote-nil? quasilist*
-                                                   quasicons quasiappend
-                                                   quasivector vquasi
-                                                   quasi)
-                                                 #((top) (top) (top) (top)
-                                                   (top) (top) (top) (top)
-                                                   (top) (top))
-                                                 #("i" "i" "i" "i" "i" "i"
-                                                   "i" "i" "i" "i"))
-                                               #(top-ribcage *top* #t)))
-                                          g2687)])
-                                     g2686)
-                                   (#%syntax-error g2685))])
-                             (#%$syntax-dispatch g2685 'each-any))])
-                         g2684)))])
-             (((case-lambda
-                 [(g2688)
-                  ((case-lambda [(g2689) (begin (set! g2688 g2689) g2688)])
-                    (case-lambda
-                      [(g2690)
-                       (if ((top-level-value 'null?) g2690)
-                           (if (g2622 g2683)
-                               '()
-                               ((top-level-value 'list) g2683))
-                           (if (g2622 ((top-level-value 'car) g2690))
-                               (g2688 ((top-level-value 'cdr) g2690))
-                               ((top-level-value 'cons)
-                                 ((top-level-value 'car) g2690)
-                                 (g2688
-                                   ((top-level-value 'cdr) g2690)))))]))])
-                (void))
-               g2682))])
-        (case-lambda
-          [(g2691)
-           ((case-lambda
-              [(g2692)
-               ((case-lambda
-                  [(g2693)
-                   ((case-lambda
-                      [(g2694)
-                       ((case-lambda
-                          [(g2695)
-                           (if (if g2695
-                                   (#%apply
-                                     (case-lambda
-                                       [(g2696 g2697) (g2619 g2696)])
-                                     g2695)
-                                   '#f)
-                               (#%apply
-                                 (case-lambda
-                                   [(g2698 g2699)
-                                    (#%list
-                                      '#(syntax-object quote
-                                         ((top)
-                                           #(ribcage #(quote? x)
-                                             #((top) (top)) #("i" "i"))
-                                           #(ribcage #(pat-x) #((top))
-                                             #("i"))
-                                           #(ribcage () () ())
-                                           #(ribcage #(x) #((top)) #("i"))
-                                           #(ribcage
-                                             #(isquote? islist? iscons?
-                                               quote-nil? quasilist*
-                                               quasicons quasiappend
-                                               quasivector vquasi quasi)
-                                             #((top) (top) (top) (top)
-                                               (top) (top) (top) (top)
-                                               (top) (top))
-                                             #("i" "i" "i" "i" "i" "i" "i"
-                                               "i" "i" "i"))
-                                           #(top-ribcage *top* #t)))
-                                      (#%list->vector g2699))])
-                                 g2695)
-                               ((case-lambda
-                                  [(g2700)
-                                   (((case-lambda
-                                       [(g2701)
-                                        ((case-lambda
-                                           [(g2702)
-                                            (begin
-                                              (set! g2701 g2702)
-                                              g2701)])
-                                          (case-lambda
-                                            [(g2703 g2704)
-                                             ((case-lambda
-                                                [(g2705)
-                                                 ((case-lambda
-                                                    [(g2706)
-                                                     (if (if g2706
-                                                             (#%apply
-                                                               (case-lambda
-                                                                 [(g2707
-                                                                   g2708)
-                                                                  (g2619
-                                                                    g2707)])
-                                                               g2706)
-                                                             '#f)
-                                                         (#%apply
-                                                           (case-lambda
-                                                             [(g2709 g2710)
-                                                              (g2704
-                                                                (#%map
-                                                                  (case-lambda
-                                                                    [(g2711)
-                                                                     (#%list
-                                                                       '#(syntax-object
-                                                                          quote
-                                                                          ((top)
-                                                                            #(ribcage
-                                                                              #(quote?
-                                                                                x)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(x
-                                                                                k)
-                                                                              #((top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"))
-                                                                            #(ribcage
-                                                                              #(f)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              #(_)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              #(pat-x)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              ()
-                                                                              ()
-                                                                              ())
-                                                                            #(ribcage
-                                                                              #(x)
-                                                                              #((top))
-                                                                              #("i"))
-                                                                            #(ribcage
-                                                                              #(isquote?
-                                                                                islist?
-                                                                                iscons?
-                                                                                quote-nil?
-                                                                                quasilist*
-                                                                                quasicons
-                                                                                quasiappend
-                                                                                quasivector
-                                                                                vquasi
-                                                                                quasi)
-                                                                              #((top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top)
-                                                                                (top))
-                                                                              #("i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"
-                                                                                "i"))
-                                                                            #(top-ribcage
-                                                                              *top*
-                                                                              #t)))
-                                                                       g2711)])
-                                                                  g2710))])
-                                                           g2706)
-                                                         ((case-lambda
-                                                            [(g2712)
-                                                             (if (if g2712
-                                                                     (#%apply
-                                                                       (case-lambda
-                                                                         [(g2713
-                                                                           g2714)
-                                                                          (g2620
-                                                                            g2713)])
-                                                                       g2712)
-                                                                     '#f)
-                                                                 (#%apply
-                                                                   (case-lambda
-                                                                     [(g2715
-                                                                       g2716)
-                                                                      (g2704
-                                                                        g2716)])
-                                                                   g2712)
-                                                                 ((case-lambda
-                                                                    [(g2717)
-                                                                     (if (if g2717
-                                                                             (#%apply
-                                                                               (case-lambda
-                                                                                 [(g2718
-                                                                                   g2719
-                                                                                   g2720)
-                                                                                  (g2621
-                                                                                    g2718)])
-                                                                               g2717)
-                                                                             '#f)
-                                                                         (#%apply
-                                                                           (case-lambda
-                                                                             [(g2721
-                                                                               g2722
-                                                                               g2723)
-                                                                              (g2701
-                                                                                g2723
-                                                                                (case-lambda
-                                                                                  [(g2724)
-                                                                                   (g2704
-                                                                                     ((top-level-value
-                                                                                        'cons)
-                                                                                       g2722
-                                                                                       g2724))]))])
-                                                                           g2717)
-                                                                         ((case-lambda
-                                                                            [(g2725)
-                                                                             (#%list
-                                                                               '#(syntax-object
-                                                                                  list->vector
-                                                                                  ((top)
-                                                                                    #(ribcage
-                                                                                      #(else)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(x
-                                                                                        k)
-                                                                                      #((top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      #(f)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(_)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(pat-x)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(x)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(isquote?
-                                                                                        islist?
-                                                                                        iscons?
-                                                                                        quote-nil?
-                                                                                        quasilist*
-                                                                                        quasicons
-                                                                                        quasiappend
-                                                                                        quasivector
-                                                                                        vquasi
-                                                                                        quasi)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(top-ribcage
-                                                                                      *top*
-                                                                                      #t)))
-                                                                               g2693)])
-                                                                           g2705))])
-                                                                   (#%$syntax-dispatch
-                                                                     g2705
-                                                                     '(any any
-                                                                           any))))])
-                                                           (#%$syntax-dispatch
-                                                             g2705
-                                                             '(any .
-                                                                   each-any))))])
-                                                   (#%$syntax-dispatch
-                                                     g2705
-                                                     '(any each-any)))])
-                                               g2703)]))])
-                                      (void))
-                                     g2691
-                                     (case-lambda
-                                       [(g2726)
-                                        ((top-level-value 'cons)
-                                          '#(syntax-object vector
-                                             ((top) #(ribcage () () ())
-                                               #(ribcage #(ls) #((top))
-                                                 #("i"))
-                                               #(ribcage #(_) #((top))
-                                                 #("i"))
-                                               #(ribcage #(pat-x) #((top))
-                                                 #("i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(ribcage
-                                                 #(isquote? islist? iscons?
-                                                   quote-nil? quasilist*
-                                                   quasicons quasiappend
-                                                   quasivector vquasi
-                                                   quasi)
-                                                 #((top) (top) (top) (top)
-                                                   (top) (top) (top) (top)
-                                                   (top) (top))
-                                                 #("i" "i" "i" "i" "i" "i"
-                                                   "i" "i" "i" "i"))
-                                               #(top-ribcage *top* #t)))
-                                          g2726)]))])
-                                 g2694))])
-                         (#%$syntax-dispatch g2694 '(any each-any)))])
-                     g2693)])
-                 g2692)])
-             g2691)])
-        (case-lambda
-          [(g2727 g2728)
-           ((case-lambda
-              [(g2729)
-               ((case-lambda
-                  [(g2730)
-                   (if g2730
-                       (#%apply
-                         (case-lambda
-                           [(g2731 g2732)
-                            ((case-lambda
-                               [(g2733)
-                                ((case-lambda
-                                   [(g2734)
-                                    (if g2734
-                                        (#%apply
-                                          (case-lambda
-                                            [(g2735)
-                                             (if ((top-level-value 'fx=)
-                                                   g2728
-                                                   '0)
-                                                 (g2623
-                                                   g2735
-                                                   (g2627 g2732 g2728))
-                                                 (g2624
-                                                   (g2624
-                                                     '#(syntax-object
-                                                        'unquote
-                                                        ((top)
-                                                          #(ribcage #(p)
-                                                            #((top))
-                                                            #("i"))
-                                                          #(ribcage #(p q)
-                                                            #((top) (top))
-                                                            #("i" "i"))
-                                                          #(ribcage () ()
-                                                            ())
-                                                          #(ribcage
-                                                            #(p lev)
-                                                            #((top) (top))
-                                                            #("i" "i"))
-                                                          #(ribcage
-                                                            #(isquote?
-                                                              islist?
-                                                              iscons?
-                                                              quote-nil?
-                                                              quasilist*
-                                                              quasicons
-                                                              quasiappend
-                                                              quasivector
-                                                              vquasi quasi)
-                                                            #((top) (top)
-                                                              (top) (top)
-                                                              (top) (top)
-                                                              (top) (top)
-                                                              (top) (top))
-                                                            #("i" "i" "i"
-                                                              "i" "i" "i"
-                                                              "i" "i" "i"
-                                                              "i"))
-                                                          #(top-ribcage
-                                                            *top* #t)))
-                                                     (g2628
-                                                       g2735
-                                                       ((top-level-value
-                                                          'fx-)
-                                                         g2728
-                                                         '1)))
-                                                   (g2627 g2732 g2728)))])
-                                          g2734)
-                                        ((case-lambda
-                                           [(g2736)
-                                            (if g2736
-                                                (#%apply
-                                                  (case-lambda
-                                                    [(g2737)
-                                                     (if ((top-level-value
-                                                            'fx=)
-                                                           g2728
-                                                           '0)
-                                                         (g2625
-                                                           g2737
-                                                           (g2627
-                                                             g2732
-                                                             g2728))
-                                                         (g2624
-                                                           (g2624
-                                                             '#(syntax-object
-                                                                'unquote-splicing
-                                                                ((top)
-                                                                  #(ribcage
-                                                                    #(p)
-                                                                    #((top))
-                                                                    #("i"))
-                                                                  #(ribcage
-                                                                    #(p q)
-                                                                    #((top)
-                                                                      (top))
-                                                                    #("i"
-                                                                      "i"))
-                                                                  #(ribcage
-                                                                    () ()
-                                                                    ())
-                                                                  #(ribcage
-                                                                    #(p
-                                                                      lev)
-                                                                    #((top)
-                                                                      (top))
-                                                                    #("i"
-                                                                      "i"))
-                                                                  #(ribcage
-                                                                    #(isquote?
-                                                                      islist?
-                                                                      iscons?
-                                                                      quote-nil?
-                                                                      quasilist*
-                                                                      quasicons
-                                                                      quasiappend
-                                                                      quasivector
-                                                                      vquasi
-                                                                      quasi)
-                                                                    #((top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top)
-                                                                      (top))
-                                                                    #("i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"
-                                                                      "i"))
-                                                                  #(top-ribcage
-                                                                    *top*
-                                                                    #t)))
-                                                             (g2628
-                                                               g2737
-                                                               ((top-level-value
-                                                                  'fx-)
-                                                                 g2728
-                                                                 '1)))
-                                                           (g2627
-                                                             g2732
-                                                             g2728)))])
-                                                  g2736)
-                                                ((case-lambda
-                                                   [(g2738)
-                                                    (g2624
-                                                      (g2628 g2738 g2728)
-                                                      (g2627
-                                                        g2732
-                                                        g2728))])
-                                                  g2733))])
-                                          (#%$syntax-dispatch
-                                            g2733
-                                            '(#(free-id
-                                                #(syntax-object
-                                                  unquote-splicing
-                                                  ((top)
-                                                    #(ribcage #(p q)
-                                                      #((top) (top))
-                                                      #("i" "i"))
-                                                    #(ribcage () () ())
-                                                    #(ribcage #(p lev)
-                                                      #((top) (top))
-                                                      #("i" "i"))
-                                                    #(ribcage
-                                                      #(isquote? islist?
-                                                        iscons? quote-nil?
-                                                        quasilist*
-                                                        quasicons
-                                                        quasiappend
-                                                        quasivector vquasi
-                                                        quasi)
-                                                      #((top) (top) (top)
-                                                        (top) (top) (top)
-                                                        (top) (top) (top)
-                                                        (top))
-                                                      #("i" "i" "i" "i" "i"
-                                                        "i" "i" "i" "i"
-                                                        "i"))
-                                                    #(top-ribcage *top*
-                                                      #t))))
-                                               .
-                                               each-any))))])
-                                  (#%$syntax-dispatch
-                                    g2733
-                                    '(#(free-id
-                                        #(syntax-object unquote
-                                          ((top)
-                                            #(ribcage #(p q) #((top) (top))
-                                              #("i" "i"))
-                                            #(ribcage () () ())
-                                            #(ribcage #(p lev)
-                                              #((top) (top)) #("i" "i"))
-                                            #(ribcage
-                                              #(isquote? islist? iscons?
-                                                quote-nil? quasilist*
-                                                quasicons quasiappend
-                                                quasivector vquasi quasi)
-                                              #((top) (top) (top) (top)
-                                                (top) (top) (top) (top)
-                                                (top) (top))
-                                              #("i" "i" "i" "i" "i" "i" "i"
-                                                "i" "i" "i"))
-                                            #(top-ribcage *top* #t))))
-                                       .
-                                       each-any)))])
-                              g2731)])
-                         g2730)
-                       ((case-lambda
-                          [(g2739)
-                           (if g2739
-                               (#%apply
-                                 (case-lambda
-                                   [()
-                                    '#(syntax-object '()
-                                       ((top)
-                                         #(ribcage () () ())
-                                         #(ribcage #(p lev) #((top) (top))
-                                           #("i" "i"))
-                                         #(ribcage
-                                           #(isquote? islist? iscons?
-                                             quote-nil? quasilist*
-                                             quasicons quasiappend
-                                             quasivector vquasi quasi)
-                                           #((top) (top) (top) (top) (top)
-                                             (top) (top) (top) (top) (top))
-                                           #("i" "i" "i" "i" "i" "i" "i"
-                                             "i" "i" "i"))
-                                         #(top-ribcage *top* #t)))])
-                                 g2739)
-                               (#%syntax-error g2729))])
-                         (#%$syntax-dispatch g2729 '())))])
-                 (#%$syntax-dispatch g2729 '(any . any)))])
-             g2727)])
-        (case-lambda
-          [(g2740 g2741)
-           ((case-lambda
-              [(g2742)
-               ((case-lambda
-                  [(g2743)
-                   (if g2743
-                       (#%apply
-                         (case-lambda
-                           [(g2744)
-                            (if ((top-level-value 'fx=) g2741 '0)
-                                g2744
-                                (g2624
-                                  '#(syntax-object 'unquote
-                                     ((top) #(ribcage #(p) #((top)) #("i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(p lev) #((top) (top))
-                                         #("i" "i"))
-                                       #(ribcage
-                                         #(isquote? islist? iscons?
-                                           quote-nil? quasilist* quasicons
-                                           quasiappend quasivector vquasi
-                                           quasi)
-                                         #((top) (top) (top) (top) (top)
-                                           (top) (top) (top) (top) (top))
-                                         #("i" "i" "i" "i" "i" "i" "i" "i"
-                                           "i" "i"))
-                                       #(top-ribcage *top* #t)))
-                                  (g2628
-                                    (#%list g2744)
-                                    ((top-level-value 'fx-) g2741 '1))))])
-                         g2743)
-                       ((case-lambda
-                          [(g2745)
-                           (if g2745
-                               (#%apply
-                                 (case-lambda
-                                   [(g2746 g2747)
-                                    (if ((top-level-value 'fx=) g2741 '0)
-                                        (g2623 g2746 (g2628 g2747 g2741))
-                                        (g2624
-                                          (g2624
-                                            '#(syntax-object 'unquote
-                                               ((top)
-                                                 #(ribcage #(p q)
-                                                   #((top) (top))
-                                                   #("i" "i"))
-                                                 #(ribcage () () ())
-                                                 #(ribcage #(p lev)
-                                                   #((top) (top))
-                                                   #("i" "i"))
-                                                 #(ribcage
-                                                   #(isquote? islist?
-                                                     iscons? quote-nil?
-                                                     quasilist* quasicons
-                                                     quasiappend
-                                                     quasivector vquasi
-                                                     quasi)
-                                                   #((top) (top) (top)
-                                                     (top) (top) (top)
-                                                     (top) (top) (top)
-                                                     (top))
-                                                   #("i" "i" "i" "i" "i"
-                                                     "i" "i" "i" "i" "i"))
-                                                 #(top-ribcage *top* #t)))
-                                            (g2628
-                                              g2746
-                                              ((top-level-value 'fx-)
-                                                g2741
-                                                '1)))
-                                          (g2628 g2747 g2741)))])
-                                 g2745)
-                               ((case-lambda
-                                  [(g2748)
-                                   (if g2748
-                                       (#%apply
-                                         (case-lambda
-                                           [(g2749 g2750)
-                                            (if ((top-level-value 'fx=)
-                                                  g2741
-                                                  '0)
-                                                (g2625
-                                                  g2749
-                                                  (g2628 g2750 g2741))
-                                                (g2624
-                                                  (g2624
-                                                    '#(syntax-object
-                                                       'unquote-splicing
-                                                       ((top)
-                                                         #(ribcage #(p q)
-                                                           #((top) (top))
-                                                           #("i" "i"))
-                                                         #(ribcage () ()
-                                                           ())
-                                                         #(ribcage #(p lev)
-                                                           #((top) (top))
-                                                           #("i" "i"))
-                                                         #(ribcage
-                                                           #(isquote?
-                                                             islist?
-                                                             iscons?
-                                                             quote-nil?
-                                                             quasilist*
-                                                             quasicons
-                                                             quasiappend
-                                                             quasivector
-                                                             vquasi quasi)
-                                                           #((top) (top)
-                                                             (top) (top)
-                                                             (top) (top)
-                                                             (top) (top)
-                                                             (top) (top))
-                                                           #("i" "i" "i"
-                                                             "i" "i" "i"
-                                                             "i" "i" "i"
-                                                             "i"))
-                                                         #(top-ribcage
-                                                           *top* #t)))
-                                                    (g2628
-                                                      g2749
-                                                      ((top-level-value
-                                                         'fx-)
-                                                        g2741
-                                                        '1)))
-                                                  (g2628 g2750 g2741)))])
-                                         g2748)
-                                       ((case-lambda
-                                          [(g2751)
-                                           (if g2751
-                                               (#%apply
-                                                 (case-lambda
-                                                   [(g2752)
-                                                    (g2624
-                                                      '#(syntax-object
-                                                         'quasiquote
-                                                         ((top)
-                                                           #(ribcage #(p)
-                                                             #((top))
-                                                             #("i"))
-                                                           #(ribcage () ()
-                                                             ())
-                                                           #(ribcage
-                                                             #(p lev)
-                                                             #((top) (top))
-                                                             #("i" "i"))
-                                                           #(ribcage
-                                                             #(isquote?
-                                                               islist?
-                                                               iscons?
-                                                               quote-nil?
-                                                               quasilist*
-                                                               quasicons
-                                                               quasiappend
-                                                               quasivector
-                                                               vquasi
-                                                               quasi)
-                                                             #((top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top)
-                                                               (top) (top))
-                                                             #("i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i" "i" "i"
-                                                               "i"))
-                                                           #(top-ribcage
-                                                             *top* #t)))
-                                                      (g2628
-                                                        (#%list g2752)
-                                                        ((top-level-value
-                                                           'fx+)
-                                                          g2741
-                                                          '1)))])
-                                                 g2751)
-                                               ((case-lambda
-                                                  [(g2753)
-                                                   (if g2753
-                                                       (#%apply
-                                                         (case-lambda
-                                                           [(g2754 g2755)
-                                                            (g2624
-                                                              (g2628
-                                                                g2754
-                                                                g2741)
-                                                              (g2628
-                                                                g2755
-                                                                g2741))])
-                                                         g2753)
-                                                       ((case-lambda
-                                                          [(g2756)
-                                                           (if g2756
-                                                               (#%apply
-                                                                 (case-lambda
-                                                                   [(g2757)
-                                                                    (g2626
-                                                                      (g2627
-                                                                        g2757
-                                                                        g2741))])
-                                                                 g2756)
-                                                               ((case-lambda
-                                                                  [(g2758)
-                                                                   (#%list
-                                                                     '#(syntax-object
-                                                                        quote
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(p)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(p
-                                                                              lev)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(isquote?
-                                                                              islist?
-                                                                              iscons?
-                                                                              quote-nil?
-                                                                              quasilist*
-                                                                              quasicons
-                                                                              quasiappend
-                                                                              quasivector
-                                                                              vquasi
-                                                                              quasi)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t)))
-                                                                     g2758)])
-                                                                 g2742))])
-                                                         (#%$syntax-dispatch
-                                                           g2742
-                                                           '#(vector
-                                                              each-any))))])
-                                                 (#%$syntax-dispatch
-                                                   g2742
-                                                   '(any . any))))])
-                                         (#%$syntax-dispatch
-                                           g2742
-                                           '(#(free-id
-                                               #(syntax-object quasiquote
-                                                 ((top)
-                                                   #(ribcage () () ())
-                                                   #(ribcage #(p lev)
-                                                     #((top) (top))
-                                                     #("i" "i"))
-                                                   #(ribcage
-                                                     #(isquote? islist?
-                                                       iscons? quote-nil?
-                                                       quasilist* quasicons
-                                                       quasiappend
-                                                       quasivector vquasi
-                                                       quasi)
-                                                     #((top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top) (top) (top)
-                                                       (top))
-                                                     #("i" "i" "i" "i" "i"
-                                                       "i" "i" "i" "i"
-                                                       "i"))
-                                                   #(top-ribcage *top*
-                                                     #t))))
-                                              any))))])
-                                 (#%$syntax-dispatch
-                                   g2742
-                                   '((#(free-id
-                                        #(syntax-object unquote-splicing
-                                          ((top)
-                                            #(ribcage () () ())
-                                            #(ribcage #(p lev)
-                                              #((top) (top)) #("i" "i"))
-                                            #(ribcage
-                                              #(isquote? islist? iscons?
-                                                quote-nil? quasilist*
-                                                quasicons quasiappend
-                                                quasivector vquasi quasi)
-                                              #((top) (top) (top) (top)
-                                                (top) (top) (top) (top)
-                                                (top) (top))
-                                              #("i" "i" "i" "i" "i" "i" "i"
-                                                "i" "i" "i"))
-                                            #(top-ribcage *top* #t))))
-                                       .
-                                       each-any)
-                                      .
-                                      any))))])
-                         (#%$syntax-dispatch
-                           g2742
-                           '((#(free-id
-                                #(syntax-object unquote
-                                  ((top)
-                                    #(ribcage () () ())
-                                    #(ribcage #(p lev) #((top) (top))
-                                      #("i" "i"))
-                                    #(ribcage
-                                      #(isquote? islist? iscons? quote-nil?
-                                        quasilist* quasicons quasiappend
-                                        quasivector vquasi quasi)
-                                      #((top) (top) (top) (top) (top) (top)
-                                        (top) (top) (top) (top))
-                                      #("i" "i" "i" "i" "i" "i" "i" "i" "i"
-                                        "i"))
-                                    #(top-ribcage *top* #t))))
-                               .
-                               each-any)
-                              .
-                              any))))])
-                 (#%$syntax-dispatch
-                   g2742
-                   '(#(free-id
-                       #(syntax-object unquote
-                         ((top)
-                           #(ribcage () () ())
-                           #(ribcage #(p lev) #((top) (top)) #("i" "i"))
-                           #(ribcage
-                             #(isquote? islist? iscons? quote-nil?
-                               quasilist* quasicons quasiappend quasivector
-                               vquasi quasi)
-                             #((top) (top) (top) (top) (top) (top) (top)
-                               (top) (top) (top))
-                             #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i"))
-                           #(top-ribcage *top* #t))))
-                      any)))])
-             g2740)]))]) (void) (void) (void) (void) (void) (void) (void)
-    (void) (void) (void))
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object unquote
-     ((top) #(ribcage #(unquote) #((top)) #(unquote))))
-  (case-lambda
-    [(g2759)
-     ((top-level-value 'syntax-error) g2759 '"misplaced")])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object unquote-splicing
-     ((top)
-       #(ribcage #(unquote-splicing) #((top))
-         #(unquote-splicing))))
-  (case-lambda
-    [(g2760)
-     ((top-level-value 'syntax-error) g2760 '"misplaced")])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object quasisyntax
-     ((top) #(ribcage #(quasisyntax) #((top)) #(quasisyntax))))
-  (case-lambda
-    [(g2761)
-     ((case-lambda
-        [(g2762 g2763)
-         ((case-lambda
-            [(g2764 g2765)
-             (begin
-               (set! g2762 g2764)
-               (set! g2763 g2765)
-               ((case-lambda
-                  [(g2766)
-                   ((case-lambda
-                      [(g2767)
-                       (if g2767
-                           (#%apply
-                             (case-lambda
-                               [(g2768 g2769)
-                                (g2762
-                                  g2769
-                                  '0
-                                  '()
-                                  (case-lambda
-                                    [(g2770 g2771)
-                                     (if ((top-level-value 'eq?)
-                                           g2771
-                                           g2769)
-                                         (#%list
-                                           '#(syntax-object syntax
-                                              ((top) #(ribcage () () ())
-                                                #(ribcage #(b* xnew)
-                                                  #((top) (top))
-                                                  #("i" "i"))
-                                                #(ribcage #(_ x)
-                                                  #((top) (top))
-                                                  #("i" "i"))
-                                                #(ribcage (vqs qs)
-                                                  ((top) (top)) ("i" "i"))
-                                                #(ribcage #(x) #((top))
-                                                  #("i"))
-                                                #(top-ribcage *top* #t)))
-                                           g2769)
-                                         ((case-lambda
-                                            [(g2772)
-                                             ((case-lambda
-                                                [(g2773)
-                                                 (if g2773
-                                                     (#%apply
-                                                       (case-lambda
-                                                         [(g2774 g2775)
-                                                          (#%list
-                                                            '#(syntax-object
-                                                               with-syntax
-                                                               ((top)
-                                                                 #(ribcage
-                                                                   #(b x)
-                                                                   #((top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   () ()
-                                                                   ())
-                                                                 #(ribcage
-                                                                   #(b*
-                                                                     xnew)
-                                                                   #((top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   #(_ x)
-                                                                   #((top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   (vqs qs)
-                                                                   ((top)
-                                                                     (top))
-                                                                   ("i" "i"))
-                                                                 #(ribcage
-                                                                   #(x)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(top-ribcage
-                                                                   *top*
-                                                                   #t)))
-                                                            g2774
-                                                            (#%list
-                                                              '#(syntax-object
-                                                                 syntax
-                                                                 ((top)
-                                                                   #(ribcage
-                                                                     #(b x)
-                                                                     #((top)
-                                                                       (top))
-                                                                     #("i"
-                                                                       "i"))
-                                                                   #(ribcage
-                                                                     () ()
-                                                                     ())
-                                                                   #(ribcage
-                                                                     #(b*
-                                                                       xnew)
-                                                                     #((top)
-                                                                       (top))
-                                                                     #("i"
-                                                                       "i"))
-                                                                   #(ribcage
-                                                                     #(_ x)
-                                                                     #((top)
-                                                                       (top))
-                                                                     #("i"
-                                                                       "i"))
-                                                                   #(ribcage
-                                                                     (vqs qs)
-                                                                     ((top)
-                                                                       (top))
-                                                                     ("i" "i"))
-                                                                   #(ribcage
-                                                                     #(x)
-                                                                     #((top))
-                                                                     #("i"))
-                                                                   #(top-ribcage
-                                                                     *top*
-                                                                     #t)))
-                                                              g2775))])
-                                                       g2773)
-                                                     (#%syntax-error
-                                                       g2772))])
-                                               (#%$syntax-dispatch
-                                                 g2772
-                                                 '(each-any any)))])
-                                           ((top-level-value 'list)
-                                             g2770
-                                             g2771)))]))])
-                             g2767)
-                           (#%syntax-error g2766))])
-                     (#%$syntax-dispatch g2766 '(any any)))])
-                 g2761))])
-           (case-lambda
-             [(g2776 g2777 g2778 g2779)
-              ((case-lambda
-                 [(g2780)
-                  ((case-lambda
-                     [(g2781)
-                      (if g2781
-                          (#%apply
-                            (case-lambda
-                              [(g2782)
-                               (g2762
-                                 g2782
-                                 ((top-level-value 'fx+) g2777 '1)
-                                 g2778
-                                 (case-lambda
-                                   [(g2783 g2784)
-                                    (g2779
-                                      g2783
-                                      (if ((top-level-value 'eq?)
-                                            g2784
-                                            g2782)
-                                          g2776
-                                          ((case-lambda
-                                             [(g2785)
-                                              ((case-lambda
-                                                 [(g2786)
-                                                  (#%cons
-                                                    '#(syntax-object
-                                                       quasisyntax
-                                                       ((top)
-                                                         #(ribcage #(d)
-                                                           #((top)) #("i"))
-                                                         #(ribcage () ()
-                                                           ())
-                                                         #(ribcage
-                                                           #(b* dnew)
-                                                           #((top) (top))
-                                                           #("i" "i"))
-                                                         #(ribcage #(d)
-                                                           #((top)) #("i"))
-                                                         #(ribcage () ()
-                                                           ())
-                                                         #(ribcage
-                                                           #(q n b* k)
-                                                           #((top) (top)
-                                                             (top) (top))
-                                                           #("i" "i" "i"
-                                                             "i"))
-                                                         #(ribcage (vqs qs)
-                                                           ((top) (top))
-                                                           ("i" "i"))
-                                                         #(ribcage #(x)
-                                                           #((top)) #("i"))
-                                                         #(top-ribcage
-                                                           *top* #t)))
-                                                    g2786)])
-                                                g2785)])
-                                            g2784)))]))])
-                            g2781)
-                          ((case-lambda
-                             [(g2787)
-                              (if (if g2787
-                                      (#%apply
-                                        (case-lambda
-                                          [(g2788)
-                                           ((top-level-value 'not)
-                                             ((top-level-value 'fx=)
-                                               g2777
-                                               '0))])
-                                        g2787)
-                                      '#f)
-                                  (#%apply
-                                    (case-lambda
-                                      [(g2789)
-                                       (g2762
-                                         g2789
-                                         ((top-level-value 'fx-) g2777 '1)
-                                         g2778
-                                         (case-lambda
-                                           [(g2790 g2791)
-                                            (g2779
-                                              g2790
-                                              (if ((top-level-value 'eq?)
-                                                    g2791
-                                                    g2789)
-                                                  g2776
-                                                  ((case-lambda
-                                                     [(g2792)
-                                                      ((case-lambda
-                                                         [(g2793)
-                                                          (#%cons
-                                                            '#(syntax-object
-                                                               unsyntax
-                                                               ((top)
-                                                                 #(ribcage
-                                                                   #(d)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(ribcage
-                                                                   () ()
-                                                                   ())
-                                                                 #(ribcage
-                                                                   #(b*
-                                                                     dnew)
-                                                                   #((top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   #(d)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(ribcage
-                                                                   () ()
-                                                                   ())
-                                                                 #(ribcage
-                                                                   #(q n b*
-                                                                     k)
-                                                                   #((top)
-                                                                     (top)
-                                                                     (top)
-                                                                     (top))
-                                                                   #("i"
-                                                                     "i"
-                                                                     "i"
-                                                                     "i"))
-                                                                 #(ribcage
-                                                                   (vqs qs)
-                                                                   ((top)
-                                                                     (top))
-                                                                   ("i" "i"))
-                                                                 #(ribcage
-                                                                   #(x)
-                                                                   #((top))
-                                                                   #("i"))
-                                                                 #(top-ribcage
-                                                                   *top*
-                                                                   #t)))
-                                                            g2793)])
-                                                        g2792)])
-                                                    g2791)))]))])
-                                    g2787)
-                                  ((case-lambda
-                                     [(g2794)
-                                      (if (if g2794
-                                              (#%apply
-                                                (case-lambda
-                                                  [(g2795)
-                                                   ((top-level-value 'not)
-                                                     ((top-level-value
-                                                        'fx=)
-                                                       g2777
-                                                       '0))])
-                                                g2794)
-                                              '#f)
-                                          (#%apply
-                                            (case-lambda
-                                              [(g2796)
-                                               (g2762
-                                                 g2796
-                                                 ((top-level-value 'fx-)
-                                                   g2777
-                                                   '1)
-                                                 g2778
-                                                 (case-lambda
-                                                   [(g2797 g2798)
-                                                    (g2779
-                                                      g2797
-                                                      (if ((top-level-value
-                                                             'eq?)
-                                                            g2798
-                                                            g2796)
-                                                          g2776
-                                                          ((case-lambda
-                                                             [(g2799)
-                                                              ((case-lambda
-                                                                 [(g2800)
-                                                                  (#%cons
-                                                                    '#(syntax-object
-                                                                       unsyntax-splicing
-                                                                       ((top)
-                                                                         #(ribcage
-                                                                           #(d)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(ribcage
-                                                                           ()
-                                                                           ()
-                                                                           ())
-                                                                         #(ribcage
-                                                                           #(b*
-                                                                             dnew)
-                                                                           #((top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           #(d)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(ribcage
-                                                                           ()
-                                                                           ()
-                                                                           ())
-                                                                         #(ribcage
-                                                                           #(q
-                                                                             n
-                                                                             b*
-                                                                             k)
-                                                                           #((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           (vqs qs)
-                                                                           ((top)
-                                                                             (top))
-                                                                           ("i" "i"))
-                                                                         #(ribcage
-                                                                           #(x)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(top-ribcage
-                                                                           *top*
-                                                                           #t)))
-                                                                    g2800)])
-                                                                g2799)])
-                                                            g2798)))]))])
-                                            g2794)
-                                          ((case-lambda
-                                             [(g2801)
-                                              (if (if g2801
-                                                      (#%apply
-                                                        (case-lambda
-                                                          [(g2802)
-                                                           ((top-level-value
-                                                              'fx=)
-                                                             g2777
-                                                             '0)])
-                                                        g2801)
-                                                      '#f)
-                                                  (#%apply
-                                                    (case-lambda
-                                                      [(g2803)
-                                                       ((case-lambda
-                                                          [(g2804)
-                                                           ((case-lambda
-                                                              [(g2805)
-                                                               (if g2805
-                                                                   (#%apply
-                                                                     (case-lambda
-                                                                       [(g2806)
-                                                                        (g2779
-                                                                          ((top-level-value
-                                                                             'cons)
-                                                                            (#%list
-                                                                              g2806
-                                                                              g2803)
-                                                                            g2778)
-                                                                          g2806)])
-                                                                     g2805)
-                                                                   (#%syntax-error
-                                                                     g2804))])
-                                                             (#%$syntax-dispatch
-                                                               g2804
-                                                               '(any)))])
-                                                         ((top-level-value
-                                                            'generate-temporaries)
-                                                           (#%list
-                                                             g2803)))])
-                                                    g2801)
-                                                  ((case-lambda
-                                                     [(g2807)
-                                                      (if (if g2807
-                                                              (#%apply
-                                                                (case-lambda
-                                                                  [(g2808
-                                                                    g2809)
-                                                                   ((top-level-value
-                                                                      'fx=)
-                                                                     g2777
-                                                                     '0)])
-                                                                g2807)
-                                                              '#f)
-                                                          (#%apply
-                                                            (case-lambda
-                                                              [(g2810
-                                                                g2811)
-                                                               (g2762
-                                                                 g2811
-                                                                 g2777
-                                                                 g2778
-                                                                 (case-lambda
-                                                                   [(g2812
-                                                                     g2813)
-                                                                    ((case-lambda
-                                                                       [(g2814)
-                                                                        ((case-lambda
-                                                                           [(g2815)
-                                                                            (if g2815
-                                                                                (#%apply
-                                                                                  (case-lambda
-                                                                                    [(g2816)
-                                                                                     (g2779
-                                                                                       ((top-level-value
-                                                                                          'append)
-                                                                                         (#%map
-                                                                                           #%list
-                                                                                           g2816
-                                                                                           g2810)
-                                                                                         g2812)
-                                                                                       ((case-lambda
-                                                                                          [(g2817)
-                                                                                           ((case-lambda
-                                                                                              [(g2818)
-                                                                                               (#%append
-                                                                                                 g2816
-                                                                                                 g2818)])
-                                                                                             g2817)])
-                                                                                         g2813))])
-                                                                                  g2815)
-                                                                                (#%syntax-error
-                                                                                  g2814))])
-                                                                          (#%$syntax-dispatch
-                                                                            g2814
-                                                                            'each-any))])
-                                                                      ((top-level-value
-                                                                         'generate-temporaries)
-                                                                        g2810))]))])
-                                                            g2807)
-                                                          ((case-lambda
-                                                             [(g2819)
-                                                              (if (if g2819
-                                                                      (#%apply
-                                                                        (case-lambda
-                                                                          [(g2820
-                                                                            g2821)
-                                                                           ((top-level-value
-                                                                              'fx=)
-                                                                             g2777
-                                                                             '0)])
-                                                                        g2819)
-                                                                      '#f)
-                                                                  (#%apply
-                                                                    (case-lambda
-                                                                      [(g2822
-                                                                        g2823)
-                                                                       (g2762
-                                                                         g2823
-                                                                         g2777
-                                                                         g2778
-                                                                         (case-lambda
-                                                                           [(g2824
-                                                                             g2825)
-                                                                            ((case-lambda
-                                                                               [(g2826)
-                                                                                ((case-lambda
-                                                                                   [(g2827)
-                                                                                    (if g2827
-                                                                                        (#%apply
-                                                                                          (case-lambda
-                                                                                            [(g2828)
-                                                                                             (g2779
-                                                                                               ((top-level-value
-                                                                                                  'append)
-                                                                                                 (#%map
-                                                                                                   (case-lambda
-                                                                                                     [(g2829
-                                                                                                       g2830)
-                                                                                                      (#%list
-                                                                                                        (#%cons
-                                                                                                          g2830
-                                                                                                          '(#(syntax-object
-                                                                                                              ...
-                                                                                                              ((top)
-                                                                                                                #(ribcage
-                                                                                                                  #(t)
-                                                                                                                  #((top))
-                                                                                                                  #("i"))
-                                                                                                                #(ribcage
-                                                                                                                  ()
-                                                                                                                  ()
-                                                                                                                  ())
-                                                                                                                #(ribcage
-                                                                                                                  #(b*
-                                                                                                                    dnew)
-                                                                                                                  #((top)
-                                                                                                                    (top))
-                                                                                                                  #("i"
-                                                                                                                    "i"))
-                                                                                                                #(ribcage
-                                                                                                                  #(q
-                                                                                                                    d)
-                                                                                                                  #((top)
-                                                                                                                    (top))
-                                                                                                                  #("i"
-                                                                                                                    "i"))
-                                                                                                                #(ribcage
-                                                                                                                  ()
-                                                                                                                  ()
-                                                                                                                  ())
-                                                                                                                #(ribcage
-                                                                                                                  #(q
-                                                                                                                    n
-                                                                                                                    b*
-                                                                                                                    k)
-                                                                                                                  #((top)
-                                                                                                                    (top)
-                                                                                                                    (top)
-                                                                                                                    (top))
-                                                                                                                  #("i"
-                                                                                                                    "i"
-                                                                                                                    "i"
-                                                                                                                    "i"))
-                                                                                                                #(ribcage
-                                                                                                                  (vqs qs)
-                                                                                                                  ((top)
-                                                                                                                    (top))
-                                                                                                                  ("i" "i"))
-                                                                                                                #(ribcage
-                                                                                                                  #(x)
-                                                                                                                  #((top))
-                                                                                                                  #("i"))
-                                                                                                                #(top-ribcage
-                                                                                                                  *top*
-                                                                                                                  #t)))))
-                                                                                                        g2829)])
-                                                                                                   g2822
-                                                                                                   g2828)
-                                                                                                 g2824)
-                                                                                               ((case-lambda
-                                                                                                  [(g2831)
-                                                                                                   ((case-lambda
-                                                                                                      [(g2832)
-                                                                                                       (if g2832
-                                                                                                           (#%apply
-                                                                                                             (case-lambda
-                                                                                                               [(g2833)
-                                                                                                                ((case-lambda
-                                                                                                                   [(g2834)
-                                                                                                                    ((case-lambda
-                                                                                                                       [(g2835)
-                                                                                                                        (#%append
-                                                                                                                          (#%apply
-                                                                                                                            #%append
-                                                                                                                            g2833)
-                                                                                                                          g2835)])
-                                                                                                                      g2834)])
-                                                                                                                  g2825)])
-                                                                                                             g2832)
-                                                                                                           (#%syntax-error
-                                                                                                             g2831))])
-                                                                                                     (#%$syntax-dispatch
-                                                                                                       g2831
-                                                                                                       '#(each
-                                                                                                          each-any)))])
-                                                                                                 (#%map
-                                                                                                   (case-lambda
-                                                                                                     [(g2836)
-                                                                                                      (#%cons
-                                                                                                        g2836
-                                                                                                        '(#(syntax-object
-                                                                                                            ...
-                                                                                                            ((top)
-                                                                                                              #(ribcage
-                                                                                                                #(t)
-                                                                                                                #((top))
-                                                                                                                #("i"))
-                                                                                                              #(ribcage
-                                                                                                                ()
-                                                                                                                ()
-                                                                                                                ())
-                                                                                                              #(ribcage
-                                                                                                                #(b*
-                                                                                                                  dnew)
-                                                                                                                #((top)
-                                                                                                                  (top))
-                                                                                                                #("i"
-                                                                                                                  "i"))
-                                                                                                              #(ribcage
-                                                                                                                #(q
-                                                                                                                  d)
-                                                                                                                #((top)
-                                                                                                                  (top))
-                                                                                                                #("i"
-                                                                                                                  "i"))
-                                                                                                              #(ribcage
-                                                                                                                ()
-                                                                                                                ()
-                                                                                                                ())
-                                                                                                              #(ribcage
-                                                                                                                #(q
-                                                                                                                  n
-                                                                                                                  b*
-                                                                                                                  k)
-                                                                                                                #((top)
-                                                                                                                  (top)
-                                                                                                                  (top)
-                                                                                                                  (top))
-                                                                                                                #("i"
-                                                                                                                  "i"
-                                                                                                                  "i"
-                                                                                                                  "i"))
-                                                                                                              #(ribcage
-                                                                                                                (vqs qs)
-                                                                                                                ((top)
-                                                                                                                  (top))
-                                                                                                                ("i" "i"))
-                                                                                                              #(ribcage
-                                                                                                                #(x)
-                                                                                                                #((top))
-                                                                                                                #("i"))
-                                                                                                              #(top-ribcage
-                                                                                                                *top*
-                                                                                                                #t)))))])
-                                                                                                   g2828)))])
-                                                                                          g2827)
-                                                                                        (#%syntax-error
-                                                                                          g2826))])
-                                                                                  (#%$syntax-dispatch
-                                                                                    g2826
-                                                                                    'each-any))])
-                                                                              ((top-level-value
-                                                                                 'generate-temporaries)
-                                                                                g2822))]))])
-                                                                    g2819)
-                                                                  ((case-lambda
-                                                                     [(g2837)
-                                                                      (if g2837
-                                                                          (#%apply
-                                                                            (case-lambda
-                                                                              [(g2838
-                                                                                g2839)
-                                                                               (g2762
-                                                                                 g2838
-                                                                                 g2777
-                                                                                 g2778
-                                                                                 (case-lambda
-                                                                                   [(g2840
-                                                                                     g2841)
-                                                                                    (g2762
-                                                                                      g2839
-                                                                                      g2777
-                                                                                      g2840
-                                                                                      (case-lambda
-                                                                                        [(g2842
-                                                                                          g2843)
-                                                                                         (g2779
-                                                                                           g2842
-                                                                                           (if (if ((top-level-value
-                                                                                                      'eq?)
-                                                                                                     g2841
-                                                                                                     g2838)
-                                                                                                   ((top-level-value
-                                                                                                      'eq?)
-                                                                                                     g2843
-                                                                                                     g2839)
-                                                                                                   '#f)
-                                                                                               g2776
-                                                                                               ((case-lambda
-                                                                                                  [(g2844)
-                                                                                                   ((case-lambda
-                                                                                                      [(g2845)
-                                                                                                       (if g2845
-                                                                                                           (#%apply
-                                                                                                             (case-lambda
-                                                                                                               [(g2846
-                                                                                                                 g2847)
-                                                                                                                (#%cons
-                                                                                                                  g2846
-                                                                                                                  g2847)])
-                                                                                                             g2845)
-                                                                                                           (#%syntax-error
-                                                                                                             g2844))])
-                                                                                                     (#%$syntax-dispatch
-                                                                                                       g2844
-                                                                                                       '(any any)))])
-                                                                                                 ((top-level-value
-                                                                                                    'list)
-                                                                                                   g2841
-                                                                                                   g2843))))]))]))])
-                                                                            g2837)
-                                                                          ((case-lambda
-                                                                             [(g2848)
-                                                                              (if g2848
-                                                                                  (#%apply
-                                                                                    (case-lambda
-                                                                                      [(g2849)
-                                                                                       (g2763
-                                                                                         g2849
-                                                                                         g2777
-                                                                                         g2778
-                                                                                         (case-lambda
-                                                                                           [(g2850
-                                                                                             g2851)
-                                                                                            (g2779
-                                                                                              g2850
-                                                                                              (if (((case-lambda
-                                                                                                      [(g2852)
-                                                                                                       ((case-lambda
-                                                                                                          [(g2853)
-                                                                                                           (begin
-                                                                                                             (set! g2852
-                                                                                                               g2853)
-                                                                                                             g2852)])
-                                                                                                         (case-lambda
-                                                                                                           [(g2854
-                                                                                                             g2855)
-                                                                                                            (if ((top-level-value
-                                                                                                                   'null?)
-                                                                                                                  g2854)
-                                                                                                                ((top-level-value
-                                                                                                                   'null?)
-                                                                                                                  g2855)
-                                                                                                                (if ((top-level-value
-                                                                                                                       'not)
-                                                                                                                      ((top-level-value
-                                                                                                                         'null?)
-                                                                                                                        g2855))
-                                                                                                                    (if ((top-level-value
-                                                                                                                           'eq?)
-                                                                                                                          ((top-level-value
-                                                                                                                             'car)
-                                                                                                                            g2854)
-                                                                                                                          ((top-level-value
-                                                                                                                             'car)
-                                                                                                                            g2855))
-                                                                                                                        (g2852
-                                                                                                                          ((top-level-value
-                                                                                                                             'cdr)
-                                                                                                                            g2854)
-                                                                                                                          ((top-level-value
-                                                                                                                             'cdr)
-                                                                                                                            g2855))
-                                                                                                                        '#f)
-                                                                                                                    '#f))]))])
-                                                                                                     (void))
-                                                                                                    g2849
-                                                                                                    g2851)
-                                                                                                  g2776
-                                                                                                  ((case-lambda
-                                                                                                     [(g2856)
-                                                                                                      ((case-lambda
-                                                                                                         [(g2857)
-                                                                                                          (if g2857
-                                                                                                              (#%apply
-                                                                                                                (case-lambda
-                                                                                                                  [(g2858)
-                                                                                                                   (#%list->vector
-                                                                                                                     g2858)])
-                                                                                                                g2857)
-                                                                                                              (#%syntax-error
-                                                                                                                g2856))])
-                                                                                                        (#%$syntax-dispatch
-                                                                                                          g2856
-                                                                                                          'each-any))])
-                                                                                                    g2851)))]))])
-                                                                                    g2848)
-                                                                                  ((case-lambda
-                                                                                     [(g2859)
-                                                                                      (g2779
-                                                                                        g2778
-                                                                                        g2776)])
-                                                                                    g2780))])
-                                                                            (#%$syntax-dispatch
-                                                                              g2780
-                                                                              '#(vector
-                                                                                 each-any))))])
-                                                                    (#%$syntax-dispatch
-                                                                      g2780
-                                                                      '(any .
-                                                                            any))))])
-                                                            (#%$syntax-dispatch
-                                                              g2780
-                                                              '((#(free-id
-                                                                   #(syntax-object
-                                                                     unsyntax-splicing
-                                                                     ((top)
-                                                                       #(ribcage
-                                                                         ()
-                                                                         ()
-                                                                         ())
-                                                                       #(ribcage
-                                                                         #(q
-                                                                           n
-                                                                           b*
-                                                                           k)
-                                                                         #((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         (vqs qs)
-                                                                         ((top)
-                                                                           (top))
-                                                                         ("i" "i"))
-                                                                       #(ribcage
-                                                                         #(x)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(top-ribcage
-                                                                         *top*
-                                                                         #t))))
-                                                                  .
-                                                                  each-any)
-                                                                 .
-                                                                 any))))])
-                                                    (#%$syntax-dispatch
-                                                      g2780
-                                                      '((#(free-id
-                                                           #(syntax-object
-                                                             unsyntax
-                                                             ((top)
-                                                               #(ribcage ()
-                                                                 () ())
-                                                               #(ribcage
-                                                                 #(q n b*
-                                                                   k)
-                                                                 #((top)
-                                                                   (top)
-                                                                   (top)
-                                                                   (top))
-                                                                 #("i" "i"
-                                                                   "i"
-                                                                   "i"))
-                                                               #(ribcage
-                                                                 (vqs qs)
-                                                                 ((top)
-                                                                   (top))
-                                                                 ("i" "i"))
-                                                               #(ribcage
-                                                                 #(x)
-                                                                 #((top))
-                                                                 #("i"))
-                                                               #(top-ribcage
-                                                                 *top*
-                                                                 #t))))
-                                                          .
-                                                          each-any)
-                                                         .
-                                                         any))))])
-                                            (#%$syntax-dispatch
-                                              g2780
-                                              '(#(free-id
-                                                  #(syntax-object unsyntax
-                                                    ((top)
-                                                      #(ribcage () () ())
-                                                      #(ribcage #(q n b* k)
-                                                        #((top) (top) (top)
-                                                          (top))
-                                                        #("i" "i" "i" "i"))
-                                                      #(ribcage (vqs qs)
-                                                        ((top) (top))
-                                                        ("i" "i"))
-                                                      #(ribcage #(x)
-                                                        #((top)) #("i"))
-                                                      #(top-ribcage *top*
-                                                        #t))))
-                                                 any))))])
-                                    (#%$syntax-dispatch
-                                      g2780
-                                      '(#(free-id
-                                          #(syntax-object unsyntax-splicing
-                                            ((top) #(ribcage () () ())
-                                              #(ribcage #(q n b* k)
-                                                #((top) (top) (top) (top))
-                                                #("i" "i" "i" "i"))
-                                              #(ribcage (vqs qs)
-                                                ((top) (top)) ("i" "i"))
-                                              #(ribcage #(x) #((top))
-                                                #("i"))
-                                              #(top-ribcage *top* #t))))
-                                         .
-                                         any))))])
-                            (#%$syntax-dispatch
-                              g2780
-                              '(#(free-id
-                                  #(syntax-object unsyntax
-                                    ((top) #(ribcage () () ())
-                                      #(ribcage #(q n b* k)
-                                        #((top) (top) (top) (top))
-                                        #("i" "i" "i" "i"))
-                                      #(ribcage (vqs qs) ((top) (top))
-                                        ("i" "i"))
-                                      #(ribcage #(x) #((top)) #("i"))
-                                      #(top-ribcage *top* #t))))
-                                 .
-                                 any))))])
-                    (#%$syntax-dispatch
-                      g2780
-                      '(#(free-id
-                          #(syntax-object quasisyntax
-                            ((top) #(ribcage () () ())
-                              #(ribcage #(q n b* k)
-                                #((top) (top) (top) (top))
-                                #("i" "i" "i" "i"))
-                              #(ribcage (vqs qs) ((top) (top)) ("i" "i"))
-                              #(ribcage #(x) #((top)) #("i"))
-                              #(top-ribcage *top* #t))))
-                         .
-                         any)))])
-                g2776)])
-           (case-lambda
-             [(g2860 g2861 g2862 g2863)
-              (if ((top-level-value 'null?) g2860)
-                  (g2863 g2862 '())
-                  (g2763
-                    ((top-level-value 'cdr) g2860)
-                    g2861
-                    g2862
-                    (case-lambda
-                      [(g2864 g2865)
-                       ((case-lambda
-                          [(g2866)
-                           ((case-lambda
-                              [(g2867)
-                               (if (if g2867
-                                       (#%apply
-                                         (case-lambda
-                                           [(g2868)
-                                            ((top-level-value 'fx=)
-                                              g2861
-                                              '0)])
-                                         g2867)
-                                       '#f)
-                                   (#%apply
-                                     (case-lambda
-                                       [(g2869)
-                                        ((case-lambda
-                                           [(g2870)
-                                            ((case-lambda
-                                               [(g2871)
-                                                (if g2871
-                                                    (#%apply
-                                                      (case-lambda
-                                                        [(g2872)
-                                                         (g2863
-                                                           ((top-level-value
-                                                              'append)
-                                                             (#%map
-                                                               #%list
-                                                               g2872
-                                                               g2869)
-                                                             g2864)
-                                                           ((top-level-value
-                                                              'append)
-                                                             g2872
-                                                             g2865))])
-                                                      g2871)
-                                                    (#%syntax-error
-                                                      g2870))])
-                                              (#%$syntax-dispatch
-                                                g2870
-                                                'each-any))])
-                                          ((top-level-value
-                                             'generate-temporaries)
-                                            g2869))])
-                                     g2867)
-                                   ((case-lambda
-                                      [(g2873)
-                                       (if (if g2873
-                                               (#%apply
-                                                 (case-lambda
-                                                   [(g2874)
-                                                    ((top-level-value 'fx=)
-                                                      g2861
-                                                      '0)])
-                                                 g2873)
-                                               '#f)
-                                           (#%apply
-                                             (case-lambda
-                                               [(g2875)
-                                                ((case-lambda
-                                                   [(g2876)
-                                                    ((case-lambda
-                                                       [(g2877)
-                                                        (if g2877
-                                                            (#%apply
-                                                              (case-lambda
-                                                                [(g2878)
-                                                                 (g2863
-                                                                   ((top-level-value
-                                                                      'append)
-                                                                     (#%map
-                                                                       (case-lambda
-                                                                         [(g2879
-                                                                           g2880)
-                                                                          (#%list
-                                                                            (#%cons
-                                                                              g2880
-                                                                              '(#(syntax-object
-                                                                                  ...
-                                                                                  ((top)
-                                                                                    #(ribcage
-                                                                                      #(t)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      #(q)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(b*
-                                                                                        xnew*)
-                                                                                      #((top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      ()
-                                                                                      ()
-                                                                                      ())
-                                                                                    #(ribcage
-                                                                                      #(x*
-                                                                                        n
-                                                                                        b*
-                                                                                        k)
-                                                                                      #((top)
-                                                                                        (top)
-                                                                                        (top)
-                                                                                        (top))
-                                                                                      #("i"
-                                                                                        "i"
-                                                                                        "i"
-                                                                                        "i"))
-                                                                                    #(ribcage
-                                                                                      (vqs qs)
-                                                                                      ((top)
-                                                                                        (top))
-                                                                                      ("i" "i"))
-                                                                                    #(ribcage
-                                                                                      #(x)
-                                                                                      #((top))
-                                                                                      #("i"))
-                                                                                    #(top-ribcage
-                                                                                      *top*
-                                                                                      #t)))))
-                                                                            g2879)])
-                                                                       g2875
-                                                                       g2878)
-                                                                     g2864)
-                                                                   ((case-lambda
-                                                                      [(g2881)
-                                                                       ((case-lambda
-                                                                          [(g2882)
-                                                                           (if g2882
-                                                                               (#%apply
-                                                                                 (case-lambda
-                                                                                   [(g2883)
-                                                                                    ((top-level-value
-                                                                                       'append)
-                                                                                      (#%apply
-                                                                                        #%append
-                                                                                        g2883)
-                                                                                      g2865)])
-                                                                                 g2882)
-                                                                               (#%syntax-error
-                                                                                 g2881))])
-                                                                         (#%$syntax-dispatch
-                                                                           g2881
-                                                                           '#(each
-                                                                              each-any)))])
-                                                                     (#%map
-                                                                       (case-lambda
-                                                                         [(g2884)
-                                                                          (#%cons
-                                                                            g2884
-                                                                            '(#(syntax-object
-                                                                                ...
-                                                                                ((top)
-                                                                                  #(ribcage
-                                                                                    #(t)
-                                                                                    #((top))
-                                                                                    #("i"))
-                                                                                  #(ribcage
-                                                                                    #(q)
-                                                                                    #((top))
-                                                                                    #("i"))
-                                                                                  #(ribcage
-                                                                                    ()
-                                                                                    ()
-                                                                                    ())
-                                                                                  #(ribcage
-                                                                                    #(b*
-                                                                                      xnew*)
-                                                                                    #((top)
-                                                                                      (top))
-                                                                                    #("i"
-                                                                                      "i"))
-                                                                                  #(ribcage
-                                                                                    ()
-                                                                                    ()
-                                                                                    ())
-                                                                                  #(ribcage
-                                                                                    #(x*
-                                                                                      n
-                                                                                      b*
-                                                                                      k)
-                                                                                    #((top)
-                                                                                      (top)
-                                                                                      (top)
-                                                                                      (top))
-                                                                                    #("i"
-                                                                                      "i"
-                                                                                      "i"
-                                                                                      "i"))
-                                                                                  #(ribcage
-                                                                                    (vqs qs)
-                                                                                    ((top)
-                                                                                      (top))
-                                                                                    ("i" "i"))
-                                                                                  #(ribcage
-                                                                                    #(x)
-                                                                                    #((top))
-                                                                                    #("i"))
-                                                                                  #(top-ribcage
-                                                                                    *top*
-                                                                                    #t)))))])
-                                                                       g2878)))])
-                                                              g2877)
-                                                            (#%syntax-error
-                                                              g2876))])
-                                                      (#%$syntax-dispatch
-                                                        g2876
-                                                        'each-any))])
-                                                  ((top-level-value
-                                                     'generate-temporaries)
-                                                    g2875))])
-                                             g2873)
-                                           ((case-lambda
-                                              [(g2885)
-                                               (g2762
-                                                 ((top-level-value 'car)
-                                                   g2860)
-                                                 g2861
-                                                 g2864
-                                                 (case-lambda
-                                                   [(g2886 g2887)
-                                                    (g2863
-                                                      g2886
-                                                      ((top-level-value
-                                                         'cons)
-                                                        g2887
-                                                        g2865))]))])
-                                             g2866))])
-                                     (#%$syntax-dispatch
-                                       g2866
-                                       '(#(free-id
-                                           #(syntax-object
-                                             unsyntax-splicing
-                                             ((top) #(ribcage () () ())
-                                               #(ribcage #(b* xnew*)
-                                                 #((top) (top)) #("i" "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x* n b* k)
-                                                 #((top) (top) (top) (top))
-                                                 #("i" "i" "i" "i"))
-                                               #(ribcage (vqs qs)
-                                                 ((top) (top)) ("i" "i"))
-                                               #(ribcage #(x) #((top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t))))
-                                          .
-                                          each-any))))])
-                             (#%$syntax-dispatch
-                               g2866
-                               '(#(free-id
-                                   #(syntax-object unsyntax
-                                     ((top) #(ribcage () () ())
-                                       #(ribcage #(b* xnew*) #((top) (top))
-                                         #("i" "i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(x* n b* k)
-                                         #((top) (top) (top) (top))
-                                         #("i" "i" "i" "i"))
-                                       #(ribcage (vqs qs) ((top) (top))
-                                         ("i" "i"))
-                                       #(ribcage #(x) #((top)) #("i"))
-                                       #(top-ribcage *top* #t))))
-                                  .
-                                  each-any)))])
-                         ((top-level-value 'car) g2860))])))]))])
-       (void)
-       (void))])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object unsyntax
-     ((top) #(ribcage #(unsyntax) #((top)) #(unsyntax))))
-  (case-lambda
-    [(g2888)
-     ((top-level-value 'syntax-error) g2888 '"misplaced")])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object unsyntax-splicing
-     ((top)
-       #(ribcage #(unsyntax-splicing) #((top))
-         #(unsyntax-splicing))))
-  (case-lambda
-    [(g2889)
-     ((top-level-value 'syntax-error) g2889 '"misplaced")])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object include
-     ((top) #(ribcage #(include) #((top)) #(include))))
-  (case-lambda
-    [(g2890)
-     ((case-lambda
-        [(g2891)
-         ((case-lambda
-            [(g2892)
-             (begin
-               (set! g2891 g2892)
-               ((case-lambda
-                  [(g2893)
-                   ((case-lambda
-                      [(g2894)
-                       (if g2894
-                           (#%apply
-                             (case-lambda
-                               [(g2895 g2896)
-                                ((case-lambda
-                                   [(g2897)
-                                    ((case-lambda
-                                       [(g2898)
-                                        ((case-lambda
-                                           [(g2899)
-                                            (if g2899
-                                                (#%apply
-                                                  (case-lambda
-                                                    [(g2900)
-                                                     (#%cons
-                                                       '#(syntax-object
-                                                          begin
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(exp)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(fn)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(ribcage
-                                                              #(k filename)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage
-                                                              (read-file)
-                                                              ((top))
-                                                              ("i"))
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       g2900)])
-                                                  g2899)
-                                                (#%syntax-error g2898))])
-                                          (#%$syntax-dispatch
-                                            g2898
-                                            'each-any))])
-                                      (g2891 g2897 g2895))])
-                                  ((top-level-value 'syntax-object->datum)
-                                    g2896))])
-                             g2894)
-                           (#%syntax-error g2893))])
-                     (#%$syntax-dispatch g2893 '(any any)))])
-                 g2890))])
-           (case-lambda
-             [(g2901 g2902)
-              ((case-lambda
-                 [(g2903)
-                  (((case-lambda
-                      [(g2904)
-                       ((case-lambda
-                          [(g2905) (begin (set! g2904 g2905) g2904)])
-                         (case-lambda
-                           [()
-                            ((case-lambda
-                               [(g2906)
-                                (if ((top-level-value 'eof-object?) g2906)
-                                    (begin
-                                      ((top-level-value 'close-input-port)
-                                        g2903)
-                                      '())
-                                    ((top-level-value 'cons)
-                                      ((top-level-value
-                                         'datum->syntax-object)
-                                        g2902
-                                        g2906)
-                                      (g2904)))])
-                              ((top-level-value 'read) g2903))]))])
-                     (void)))])
-                ((top-level-value 'open-input-file) g2901))]))])
-       (void))])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object case
-     ((top) #(ribcage #(case) #((top)) #(case))))
-  (case-lambda
-    [(g2907)
-     ((case-lambda
-        [(g2908)
-         ((case-lambda
-            [(g2909)
-             (if g2909
-                 (#%apply
-                   (case-lambda
-                     [(g2910 g2911 g2912 g2913)
-                      ((case-lambda
-                         [(g2914)
-                          ((case-lambda
-                             [(g2915)
-                              (#%list
-                                '#(syntax-object let
-                                   ((top)
-                                     #(ribcage #(body) #((top)) #("i"))
-                                     #(ribcage #(_ e m1 m2)
-                                       #((top) (top) (top) (top))
-                                       #("i" "i" "i" "i"))
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #((top)) #("i"))
-                                     #(top-ribcage *top* #t)))
-                                (#%list
-                                  (#%list
-                                    '#(syntax-object t
-                                       ((top)
-                                         #(ribcage #(body) #((top)) #("i"))
-                                         #(ribcage #(_ e m1 m2)
-                                           #((top) (top) (top) (top))
-                                           #("i" "i" "i" "i"))
-                                         #(ribcage () () ())
-                                         #(ribcage #(x) #((top)) #("i"))
-                                         #(top-ribcage *top* #t)))
-                                    g2911))
-                                g2915)])
-                            g2914)])
-                        (((case-lambda
-                            [(g2916)
-                             ((case-lambda
-                                [(g2917) (begin (set! g2916 g2917) g2916)])
-                               (case-lambda
-                                 [(g2918 g2919)
-                                  (if ((top-level-value 'null?) g2919)
-                                      ((case-lambda
-                                         [(g2920)
-                                          ((case-lambda
-                                             [(g2921)
-                                              (if g2921
-                                                  (#%apply
-                                                    (case-lambda
-                                                      [(g2922 g2923)
-                                                       (#%cons
-                                                         '#(syntax-object
-                                                            begin
-                                                            ((top)
-                                                              #(ribcage
-                                                                #(e1 e2)
-                                                                #((top)
-                                                                  (top))
-                                                                #("i" "i"))
-                                                              #(ribcage ()
-                                                                () ())
-                                                              #(ribcage
-                                                                #(clause
-                                                                  clauses)
-                                                                #((top)
-                                                                  (top))
-                                                                #("i" "i"))
-                                                              #(ribcage
-                                                                #(f)
-                                                                #((top))
-                                                                #("i"))
-                                                              #(ribcage
-                                                                #(_ e m1
-                                                                  m2)
-                                                                #((top)
-                                                                  (top)
-                                                                  (top)
-                                                                  (top))
-                                                                #("i" "i"
-                                                                  "i" "i"))
-                                                              #(ribcage ()
-                                                                () ())
-                                                              #(ribcage
-                                                                #(x)
-                                                                #((top))
-                                                                #("i"))
-                                                              #(top-ribcage
-                                                                *top* #t)))
-                                                         (#%cons
-                                                           g2922
-                                                           g2923))])
-                                                    g2921)
-                                                  ((case-lambda
-                                                     [(g2924)
-                                                      (if g2924
-                                                          (#%apply
-                                                            (case-lambda
-                                                              [(g2925 g2926
-                                                                g2927)
-                                                               (#%list
-                                                                 '#(syntax-object
-                                                                    if
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(k
-                                                                          e1
-                                                                          e2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          e
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 (#%list
-                                                                   '#(syntax-object
-                                                                      memv
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   '#(syntax-object
-                                                                      t
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%list
-                                                                     '#(syntax-object
-                                                                        quote
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(k
-                                                                              e1
-                                                                              e2)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(clause
-                                                                              clauses)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(f)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            #(_
-                                                                              e
-                                                                              m1
-                                                                              m2)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(x)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t)))
-                                                                     g2925))
-                                                                 (#%cons
-                                                                   '#(syntax-object
-                                                                      begin
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%cons
-                                                                     g2926
-                                                                     g2927)))])
-                                                            g2924)
-                                                          ((case-lambda
-                                                             [(g2928)
-                                                              ((top-level-value
-                                                                 'syntax-error)
-                                                                g2907)])
-                                                            g2920))])
-                                                    (#%$syntax-dispatch
-                                                      g2920
-                                                      '(each-any
-                                                         any
-                                                         .
-                                                         each-any))))])
-                                            (#%$syntax-dispatch
-                                              g2920
-                                              '(#(free-id
-                                                  #(syntax-object else
-                                                    ((top)
-                                                      #(ribcage () () ())
-                                                      #(ribcage
-                                                        #(clause clauses)
-                                                        #((top) (top))
-                                                        #("i" "i"))
-                                                      #(ribcage #(f)
-                                                        #((top)) #("i"))
-                                                      #(ribcage
-                                                        #(_ e m1 m2)
-                                                        #((top) (top) (top)
-                                                          (top))
-                                                        #("i" "i" "i" "i"))
-                                                      #(ribcage () () ())
-                                                      #(ribcage #(x)
-                                                        #((top)) #("i"))
-                                                      #(top-ribcage *top*
-                                                        #t))))
-                                                 any
-                                                 .
-                                                 each-any)))])
-                                        g2918)
-                                      ((case-lambda
-                                         [(g2929)
-                                          ((case-lambda
-                                             [(g2930)
-                                              ((case-lambda
-                                                 [(g2931)
-                                                  ((case-lambda
-                                                     [(g2932)
-                                                      (if g2932
-                                                          (#%apply
-                                                            (case-lambda
-                                                              [(g2933 g2934
-                                                                g2935)
-                                                               (#%list
-                                                                 '#(syntax-object
-                                                                    if
-                                                                    ((top)
-                                                                      #(ribcage
-                                                                        #(k
-                                                                          e1
-                                                                          e2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(rest)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(clause
-                                                                          clauses)
-                                                                        #((top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        #(f)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(ribcage
-                                                                        #(_
-                                                                          e
-                                                                          m1
-                                                                          m2)
-                                                                        #((top)
-                                                                          (top)
-                                                                          (top)
-                                                                          (top))
-                                                                        #("i"
-                                                                          "i"
-                                                                          "i"
-                                                                          "i"))
-                                                                      #(ribcage
-                                                                        ()
-                                                                        ()
-                                                                        ())
-                                                                      #(ribcage
-                                                                        #(x)
-                                                                        #((top))
-                                                                        #("i"))
-                                                                      #(top-ribcage
-                                                                        *top*
-                                                                        #t)))
-                                                                 (#%list
-                                                                   '#(syntax-object
-                                                                      memv
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(rest)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   '#(syntax-object
-                                                                      t
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(rest)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%list
-                                                                     '#(syntax-object
-                                                                        quote
-                                                                        ((top)
-                                                                          #(ribcage
-                                                                            #(k
-                                                                              e1
-                                                                              e2)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(rest)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(clause
-                                                                              clauses)
-                                                                            #((top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            #(f)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(ribcage
-                                                                            #(_
-                                                                              e
-                                                                              m1
-                                                                              m2)
-                                                                            #((top)
-                                                                              (top)
-                                                                              (top)
-                                                                              (top))
-                                                                            #("i"
-                                                                              "i"
-                                                                              "i"
-                                                                              "i"))
-                                                                          #(ribcage
-                                                                            ()
-                                                                            ()
-                                                                            ())
-                                                                          #(ribcage
-                                                                            #(x)
-                                                                            #((top))
-                                                                            #("i"))
-                                                                          #(top-ribcage
-                                                                            *top*
-                                                                            #t)))
-                                                                     g2933))
-                                                                 (#%cons
-                                                                   '#(syntax-object
-                                                                      begin
-                                                                      ((top)
-                                                                        #(ribcage
-                                                                          #(k
-                                                                            e1
-                                                                            e2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(rest)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(clause
-                                                                            clauses)
-                                                                          #((top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          #(f)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(ribcage
-                                                                          #(_
-                                                                            e
-                                                                            m1
-                                                                            m2)
-                                                                          #((top)
-                                                                            (top)
-                                                                            (top)
-                                                                            (top))
-                                                                          #("i"
-                                                                            "i"
-                                                                            "i"
-                                                                            "i"))
-                                                                        #(ribcage
-                                                                          ()
-                                                                          ()
-                                                                          ())
-                                                                        #(ribcage
-                                                                          #(x)
-                                                                          #((top))
-                                                                          #("i"))
-                                                                        #(top-ribcage
-                                                                          *top*
-                                                                          #t)))
-                                                                   (#%cons
-                                                                     g2934
-                                                                     g2935))
-                                                                 g2930)])
-                                                            g2932)
-                                                          ((case-lambda
-                                                             [(g2936)
-                                                              ((top-level-value
-                                                                 'syntax-error)
-                                                                g2907)])
-                                                            g2931))])
-                                                    (#%$syntax-dispatch
-                                                      g2931
-                                                      '(each-any
-                                                         any
-                                                         .
-                                                         each-any)))])
-                                                g2918)])
-                                            g2929)])
-                                        (g2916
-                                          ((top-level-value 'car) g2919)
-                                          ((top-level-value 'cdr)
-                                            g2919))))]))])
-                           (void))
-                          g2912
-                          g2913))])
-                   g2909)
-                 (#%syntax-error g2908))])
-           (#%$syntax-dispatch g2908 '(any any any . each-any)))])
-       g2907)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object identifier-syntax
-     ((top)
-       #(ribcage #(identifier-syntax) #((top))
-         #(identifier-syntax))))
-  (case-lambda
-    [(g2937)
-     ((case-lambda
-        [(g2938)
-         ((case-lambda
-            [(g2939)
-             (if g2939
-                 (#%apply
-                   (case-lambda
-                     [(g2940 g2941)
-                      (#%list
-                        '#(syntax-object lambda
-                           ((top)
-                             #(ribcage #(dummy e) #(("m" top) (top))
-                               #("i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #(("m" top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        '#(syntax-object (x)
-                           ((top)
-                             #(ribcage #(dummy e) #(("m" top) (top))
-                               #("i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #(("m" top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%list
-                          '#(syntax-object syntax-case
-                             ((top)
-                               #(ribcage #(dummy e) #(("m" top) (top))
-                                 #("i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #(("m" top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          '#(syntax-object x
-                             ((top)
-                               #(ribcage #(dummy e) #(("m" top) (top))
-                                 #("i" "i"))
-                               #(ribcage () () ())
-                               #(ribcage #(x) #(("m" top)) #("i"))
-                               #(top-ribcage *top* #t)))
-                          '()
-                          (#%list
-                            '#(syntax-object id
-                               ((top)
-                                 #(ribcage #(dummy e) #(("m" top) (top))
-                                   #("i" "i"))
-                                 #(ribcage () () ())
-                                 #(ribcage #(x) #(("m" top)) #("i"))
-                                 #(top-ribcage *top* #t)))
-                            '#(syntax-object (identifier? #'id)
-                               ((top)
-                                 #(ribcage #(dummy e) #(("m" top) (top))
-                                   #("i" "i"))
-                                 #(ribcage () () ())
-                                 #(ribcage #(x) #(("m" top)) #("i"))
-                                 #(top-ribcage *top* #t)))
-                            (#%list
-                              '#(syntax-object syntax
-                                 ((top)
-                                   #(ribcage #(dummy e) #(("m" top) (top))
-                                     #("i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t)))
-                              g2941))
-                          (#%list
-                            '(#(syntax-object _
-                                ((top)
-                                  #(ribcage #(dummy e) #(("m" top) (top))
-                                    #("i" "i"))
-                                  #(ribcage () () ())
-                                  #(ribcage #(x) #(("m" top)) #("i"))
-                                  #(top-ribcage *top* #t)))
-                               #(syntax-object x
-                                 ((top)
-                                   #(ribcage #(dummy e) #(("m" top) (top))
-                                     #("i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t)))
-                               #(syntax-object ...
-                                 ((top)
-                                   #(ribcage #(dummy e) #(("m" top) (top))
-                                     #("i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t))))
-                            (#%list
-                              '#(syntax-object syntax
-                                 ((top)
-                                   #(ribcage #(dummy e) #(("m" top) (top))
-                                     #("i" "i"))
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t)))
-                              (#%cons
-                                g2941
-                                '(#(syntax-object x
-                                    ((top)
-                                      #(ribcage #(dummy e)
-                                        #(("m" top) (top)) #("i" "i"))
-                                      #(ribcage () () ())
-                                      #(ribcage #(x) #(("m" top)) #("i"))
-                                      #(top-ribcage *top* #t)))
-                                   #(syntax-object ...
-                                     ((top)
-                                       #(ribcage #(dummy e)
-                                         #(("m" top) (top)) #("i" "i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(x) #(("m" top)) #("i"))
-                                       #(top-ribcage *top* #t)))))))))])
-                   g2939)
-                 ((case-lambda
-                    [(g2942)
-                     (if (if g2942
-                             (#%apply
-                               (case-lambda
-                                 [(g2943 g2944 g2945 g2946 g2947 g2948)
-                                  (if ((top-level-value 'identifier?)
-                                        g2944)
-                                      ((top-level-value 'identifier?)
-                                        g2946)
-                                      '#f)])
-                               g2942)
-                             '#f)
-                         (#%apply
-                           (case-lambda
-                             [(g2949 g2950 g2951 g2952 g2953 g2954)
-                              (#%list
-                                '#(syntax-object cons
-                                   ((top)
-                                     #(ribcage
-                                       #(dummy id exp1 var val exp2)
-                                       #(("m" top) (top) (top) (top) (top)
-                                         (top))
-                                       #("i" "i" "i" "i" "i" "i"))
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #(("m" top)) #("i"))
-                                     #(top-ribcage *top* #t)))
-                                '#(syntax-object 'macro!
-                                   ((top)
-                                     #(ribcage
-                                       #(dummy id exp1 var val exp2)
-                                       #(("m" top) (top) (top) (top) (top)
-                                         (top))
-                                       #("i" "i" "i" "i" "i" "i"))
-                                     #(ribcage () () ())
-                                     #(ribcage #(x) #(("m" top)) #("i"))
-                                     #(top-ribcage *top* #t)))
-                                (#%list
-                                  '#(syntax-object lambda
-                                     ((top)
-                                       #(ribcage
-                                         #(dummy id exp1 var val exp2)
-                                         #(("m" top) (top) (top) (top)
-                                           (top) (top))
-                                         #("i" "i" "i" "i" "i" "i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(x) #(("m" top)) #("i"))
-                                       #(top-ribcage *top* #t)))
-                                  '#(syntax-object (x)
-                                     ((top)
-                                       #(ribcage
-                                         #(dummy id exp1 var val exp2)
-                                         #(("m" top) (top) (top) (top)
-                                           (top) (top))
-                                         #("i" "i" "i" "i" "i" "i"))
-                                       #(ribcage () () ())
-                                       #(ribcage #(x) #(("m" top)) #("i"))
-                                       #(top-ribcage *top* #t)))
-                                  (#%list
-                                    '#(syntax-object syntax-case
-                                       ((top)
-                                         #(ribcage
-                                           #(dummy id exp1 var val exp2)
-                                           #(("m" top) (top) (top) (top)
-                                             (top) (top))
-                                           #("i" "i" "i" "i" "i" "i"))
-                                         #(ribcage () () ())
-                                         #(ribcage #(x) #(("m" top))
-                                           #("i"))
-                                         #(top-ribcage *top* #t)))
-                                    '#(syntax-object x
-                                       ((top)
-                                         #(ribcage
-                                           #(dummy id exp1 var val exp2)
-                                           #(("m" top) (top) (top) (top)
-                                             (top) (top))
-                                           #("i" "i" "i" "i" "i" "i"))
-                                         #(ribcage () () ())
-                                         #(ribcage #(x) #(("m" top))
-                                           #("i"))
-                                         #(top-ribcage *top* #t)))
-                                    '#(syntax-object (set!)
-                                       ((top)
-                                         #(ribcage
-                                           #(dummy id exp1 var val exp2)
-                                           #(("m" top) (top) (top) (top)
-                                             (top) (top))
-                                           #("i" "i" "i" "i" "i" "i"))
-                                         #(ribcage () () ())
-                                         #(ribcage #(x) #(("m" top))
-                                           #("i"))
-                                         #(top-ribcage *top* #t)))
-                                    (#%list
-                                      (#%list
-                                        '#(syntax-object set!
-                                           ((top)
-                                             #(ribcage
-                                               #(dummy id exp1 var val
-                                                 exp2)
-                                               #(("m" top) (top) (top)
-                                                 (top) (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #(("m" top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        g2952
-                                        g2953)
-                                      (#%list
-                                        '#(syntax-object syntax
-                                           ((top)
-                                             #(ribcage
-                                               #(dummy id exp1 var val
-                                                 exp2)
-                                               #(("m" top) (top) (top)
-                                                 (top) (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #(("m" top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        g2954))
-                                    (#%list
-                                      (#%cons
-                                        g2950
-                                        '(#(syntax-object x
-                                            ((top)
-                                              #(ribcage
-                                                #(dummy id exp1 var val
-                                                  exp2)
-                                                #(("m" top) (top) (top)
-                                                  (top) (top) (top))
-                                                #("i" "i" "i" "i" "i" "i"))
-                                              #(ribcage () () ())
-                                              #(ribcage #(x) #(("m" top))
-                                                #("i"))
-                                              #(top-ribcage *top* #t)))
-                                           #(syntax-object ...
-                                             ((top)
-                                               #(ribcage
-                                                 #(dummy id exp1 var val
-                                                   exp2)
-                                                 #(("m" top) (top) (top)
-                                                   (top) (top) (top))
-                                                 #("i" "i" "i" "i" "i"
-                                                   "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #(("m" top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))))
-                                      (#%list
-                                        '#(syntax-object syntax
-                                           ((top)
-                                             #(ribcage
-                                               #(dummy id exp1 var val
-                                                 exp2)
-                                               #(("m" top) (top) (top)
-                                                 (top) (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #(("m" top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        (#%cons
-                                          g2951
-                                          '(#(syntax-object x
-                                              ((top)
-                                                #(ribcage
-                                                  #(dummy id exp1 var val
-                                                    exp2)
-                                                  #(("m" top) (top) (top)
-                                                    (top) (top) (top))
-                                                  #("i" "i" "i" "i" "i"
-                                                    "i"))
-                                                #(ribcage () () ())
-                                                #(ribcage #(x) #(("m" top))
-                                                  #("i"))
-                                                #(top-ribcage *top* #t)))
-                                             #(syntax-object ...
-                                               ((top)
-                                                 #(ribcage
-                                                   #(dummy id exp1 var val
-                                                     exp2)
-                                                   #(("m" top) (top) (top)
-                                                     (top) (top) (top))
-                                                   #("i" "i" "i" "i" "i"
-                                                     "i"))
-                                                 #(ribcage () () ())
-                                                 #(ribcage #(x)
-                                                   #(("m" top)) #("i"))
-                                                 #(top-ribcage *top*
-                                                   #t)))))))
-                                    (#%list
-                                      g2950
-                                      (#%list
-                                        '#(syntax-object identifier?
-                                           ((top)
-                                             #(ribcage
-                                               #(dummy id exp1 var val
-                                                 exp2)
-                                               #(("m" top) (top) (top)
-                                                 (top) (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #(("m" top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        (#%list
-                                          '#(syntax-object syntax
-                                             ((top)
-                                               #(ribcage
-                                                 #(dummy id exp1 var val
-                                                   exp2)
-                                                 #(("m" top) (top) (top)
-                                                   (top) (top) (top))
-                                                 #("i" "i" "i" "i" "i"
-                                                   "i"))
-                                               #(ribcage () () ())
-                                               #(ribcage #(x) #(("m" top))
-                                                 #("i"))
-                                               #(top-ribcage *top* #t)))
-                                          g2950))
-                                      (#%list
-                                        '#(syntax-object syntax
-                                           ((top)
-                                             #(ribcage
-                                               #(dummy id exp1 var val
-                                                 exp2)
-                                               #(("m" top) (top) (top)
-                                                 (top) (top) (top))
-                                               #("i" "i" "i" "i" "i" "i"))
-                                             #(ribcage () () ())
-                                             #(ribcage #(x) #(("m" top))
-                                               #("i"))
-                                             #(top-ribcage *top* #t)))
-                                        g2951)))))])
-                           g2942)
-                         (#%syntax-error g2938))])
-                   (#%$syntax-dispatch
-                     g2938
-                     '(any (any any)
-                           ((#(free-id
-                               #(syntax-object set!
-                                 ((top)
-                                   #(ribcage () () ())
-                                   #(ribcage #(x) #(("m" top)) #("i"))
-                                   #(top-ribcage *top* #t))))
-                              any
-                              any)
-                             any)))))])
-           (#%$syntax-dispatch g2938 '(any any)))])
-       g2937)])
-  '*top*)
-
-(#%$sc-put-cte
-  '#(syntax-object parameterize
-     ((top) #(ribcage #(parameterize) #((top)) #(parameterize))))
-  (case-lambda
-    [(g2955)
-     ((case-lambda
-        [(g2956)
-         ((case-lambda
-            [(g2957)
-             (if g2957
-                 (#%apply
-                   (case-lambda
-                     [(g2958 g2959 g2960)
-                      (#%cons
-                        '#(syntax-object let
-                           ((top)
-                             #(ribcage #(_ b b*) #((top) (top) (top))
-                               #("i" "i" "i"))
-                             #(ribcage () () ())
-                             #(ribcage #(x) #((top)) #("i"))
-                             #(top-ribcage *top* #t)))
-                        (#%cons '() (#%cons g2959 g2960)))])
-                   g2957)
-                 ((case-lambda
-                    [(g2961)
-                     (if g2961
-                         (#%apply
-                           (case-lambda
-                             [(g2962 g2963 g2964 g2965 g2966)
-                              ((case-lambda
-                                 [(g2967)
-                                  ((case-lambda
-                                     [(g2968)
-                                      (if g2968
-                                          (#%apply
-                                            (case-lambda
-                                              [(g2969 g2970)
-                                               (#%list
-                                                 '#(syntax-object let
-                                                    ((top)
-                                                      #(ribcage
-                                                        #(lhs* rhs*)
-                                                        #((top) (top))
-                                                        #("i" "i"))
-                                                      #(ribcage
-                                                        #(_ olhs* orhs* b
-                                                          b*)
-                                                        #((top) (top) (top)
-                                                          (top) (top))
-                                                        #("i" "i" "i" "i"
-                                                          "i"))
-                                                      #(ribcage () () ())
-                                                      #(ribcage #(x)
-                                                        #((top)) #("i"))
-                                                      #(top-ribcage *top*
-                                                        #t)))
-                                                 (#%append
-                                                   (#%map
-                                                     #%list
-                                                     g2969
-                                                     g2963)
-                                                   (#%map
-                                                     #%list
-                                                     g2970
-                                                     g2964))
-                                                 (#%list
-                                                   '#(syntax-object let
-                                                      ((top)
-                                                        #(ribcage
-                                                          #(lhs* rhs*)
-                                                          #((top) (top))
-                                                          #("i" "i"))
-                                                        #(ribcage
-                                                          #(_ olhs* orhs* b
-                                                            b*)
-                                                          #((top) (top)
-                                                            (top) (top)
-                                                            (top))
-                                                          #("i" "i" "i" "i"
-                                                            "i"))
-                                                        #(ribcage () () ())
-                                                        #(ribcage #(x)
-                                                          #((top)) #("i"))
-                                                        #(top-ribcage *top*
-                                                          #t)))
-                                                   (#%list
-                                                     (#%list
-                                                       '#(syntax-object
-                                                          swap
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(lhs* rhs*)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage
-                                                              #(_ olhs*
-                                                                orhs* b b*)
-                                                              #((top) (top)
-                                                                (top) (top)
-                                                                (top))
-                                                              #("i" "i" "i"
-                                                                "i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%cons
-                                                         '#(syntax-object
-                                                            lambda
-                                                            ((top)
-                                                              #(ribcage
-                                                                #(lhs*
-                                                                  rhs*)
-                                                                #((top)
-                                                                  (top))
-                                                                #("i" "i"))
-                                                              #(ribcage
-                                                                #(_ olhs*
-                                                                  orhs* b
-                                                                  b*)
-                                                                #((top)
-                                                                  (top)
-                                                                  (top)
-                                                                  (top)
-                                                                  (top))
-                                                                #("i" "i"
-                                                                  "i" "i"
-                                                                  "i"))
-                                                              #(ribcage ()
-                                                                () ())
-                                                              #(ribcage
-                                                                #(x)
-                                                                #((top))
-                                                                #("i"))
-                                                              #(top-ribcage
-                                                                *top* #t)))
-                                                         (#%cons
-                                                           '()
-                                                           (#%map
-                                                             (case-lambda
-                                                               [(g2971
-                                                                 g2972)
-                                                                (#%list
-                                                                  '#(syntax-object
-                                                                     let
-                                                                     ((top)
-                                                                       #(ribcage
-                                                                         #(lhs*
-                                                                           rhs*)
-                                                                         #((top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         #(_
-                                                                           olhs*
-                                                                           orhs*
-                                                                           b
-                                                                           b*)
-                                                                         #((top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top)
-                                                                           (top))
-                                                                         #("i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"
-                                                                           "i"))
-                                                                       #(ribcage
-                                                                         ()
-                                                                         ()
-                                                                         ())
-                                                                       #(ribcage
-                                                                         #(x)
-                                                                         #((top))
-                                                                         #("i"))
-                                                                       #(top-ribcage
-                                                                         *top*
-                                                                         #t)))
-                                                                  (#%list
-                                                                    (#%list
-                                                                      '#(syntax-object
-                                                                         t
-                                                                         ((top)
-                                                                           #(ribcage
-                                                                             #(lhs*
-                                                                               rhs*)
-                                                                             #((top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             #(_
-                                                                               olhs*
-                                                                               orhs*
-                                                                               b
-                                                                               b*)
-                                                                             #((top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             ()
-                                                                             ()
-                                                                             ())
-                                                                           #(ribcage
-                                                                             #(x)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(top-ribcage
-                                                                             *top*
-                                                                             #t)))
-                                                                      (#%list
-                                                                        g2972)))
-                                                                  (#%list
-                                                                    g2972
-                                                                    g2971)
-                                                                  (#%cons
-                                                                    '#(syntax-object
-                                                                       set!
-                                                                       ((top)
-                                                                         #(ribcage
-                                                                           #(lhs*
-                                                                             rhs*)
-                                                                           #((top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           #(_
-                                                                             olhs*
-                                                                             orhs*
-                                                                             b
-                                                                             b*)
-                                                                           #((top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top)
-                                                                             (top))
-                                                                           #("i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"
-                                                                             "i"))
-                                                                         #(ribcage
-                                                                           ()
-                                                                           ()
-                                                                           ())
-                                                                         #(ribcage
-                                                                           #(x)
-                                                                           #((top))
-                                                                           #("i"))
-                                                                         #(top-ribcage
-                                                                           *top*
-                                                                           #t)))
-                                                                    (#%cons
-                                                                      g2971
-                                                                      '#(syntax-object
-                                                                         (t)
-                                                                         ((top)
-                                                                           #(ribcage
-                                                                             #(lhs*
-                                                                               rhs*)
-                                                                             #((top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             #(_
-                                                                               olhs*
-                                                                               orhs*
-                                                                               b
-                                                                               b*)
-                                                                             #((top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top)
-                                                                               (top))
-                                                                             #("i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"
-                                                                               "i"))
-                                                                           #(ribcage
-                                                                             ()
-                                                                             ()
-                                                                             ())
-                                                                           #(ribcage
-                                                                             #(x)
-                                                                             #((top))
-                                                                             #("i"))
-                                                                           #(top-ribcage
-                                                                             *top*
-                                                                             #t))))))])
-                                                             g2970
-                                                             g2969)))))
-                                                   (#%cons
-                                                     '#(syntax-object
-                                                        dynamic-wind
-                                                        ((top)
-                                                          #(ribcage
-                                                            #(lhs* rhs*)
-                                                            #((top) (top))
-                                                            #("i" "i"))
-                                                          #(ribcage
-                                                            #(_ olhs* orhs*
-                                                              b b*)
-                                                            #((top) (top)
-                                                              (top) (top)
-                                                              (top))
-                                                            #("i" "i" "i"
-                                                              "i" "i"))
-                                                          #(ribcage () ()
-                                                            ())
-                                                          #(ribcage #(x)
-                                                            #((top))
-                                                            #("i"))
-                                                          #(top-ribcage
-                                                            *top* #t)))
-                                                     (#%cons
-                                                       '#(syntax-object
-                                                          swap
-                                                          ((top)
-                                                            #(ribcage
-                                                              #(lhs* rhs*)
-                                                              #((top)
-                                                                (top))
-                                                              #("i" "i"))
-                                                            #(ribcage
-                                                              #(_ olhs*
-                                                                orhs* b b*)
-                                                              #((top) (top)
-                                                                (top) (top)
-                                                                (top))
-                                                              #("i" "i" "i"
-                                                                "i" "i"))
-                                                            #(ribcage () ()
-                                                              ())
-                                                            #(ribcage #(x)
-                                                              #((top))
-                                                              #("i"))
-                                                            #(top-ribcage
-                                                              *top* #t)))
-                                                       (#%cons
-                                                         (#%cons
-                                                           '#(syntax-object
-                                                              lambda
-                                                              ((top)
-                                                                #(ribcage
-                                                                  #(lhs*
-                                                                    rhs*)
-                                                                  #((top)
-                                                                    (top))
-                                                                  #("i"
-                                                                    "i"))
-                                                                #(ribcage
-                                                                  #(_ olhs*
-                                                                    orhs* b
-                                                                    b*)
-                                                                  #((top)
-                                                                    (top)
-                                                                    (top)
-                                                                    (top)
-                                                                    (top))
-                                                                  #("i" "i"
-                                                                    "i" "i"
-                                                                    "i"))
-                                                                #(ribcage
-                                                                  () () ())
-                                                                #(ribcage
-                                                                  #(x)
-                                                                  #((top))
-                                                                  #("i"))
-                                                                #(top-ribcage
-                                                                  *top*
-                                                                  #t)))
-                                                           (#%cons
-                                                             '()
-                                                             (#%cons
-                                                               g2965
-                                                               g2966)))
-                                                         '#(syntax-object
-                                                            (swap)
-                                                            ((top)
-                                                              #(ribcage
-                                                                #(lhs*
-                                                                  rhs*)
-                                                                #((top)
-                                                                  (top))
-                                                                #("i" "i"))
-                                                              #(ribcage
-                                                                #(_ olhs*
-                                                                  orhs* b
-                                                                  b*)
-                                                                #((top)
-                                                                  (top)
-                                                                  (top)
-                                                                  (top)
-                                                                  (top))
-                                                                #("i" "i"
-                                                                  "i" "i"
-                                                                  "i"))
-                                                              #(ribcage ()
-                                                                () ())
-                                                              #(ribcage
-                                                                #(x)
-                                                                #((top))
-                                                                #("i"))
-                                                              #(top-ribcage
-                                                                *top*
-                                                                #t))))))))])
-                                            g2968)
-                                          (#%syntax-error g2967))])
-                                    (#%$syntax-dispatch
-                                      g2967
-                                      '(each-any each-any)))])
-                                ((top-level-value 'list)
-                                  ((top-level-value 'generate-temporaries)
-                                    g2963)
-                                  ((top-level-value 'generate-temporaries)
-                                    g2964)))])
-                           g2961)
-                         (#%syntax-error g2956))])
-                   (#%$syntax-dispatch
-                     g2956
-                     '(any #(each (any any)) any . each-any))))])
-           (#%$syntax-dispatch g2956 '(any () any . each-any)))])
-       g2955)])
-  '*top*)
-